<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE Safe #-}</span><span>
</span><span id="line-2"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-3"></span><span class="hs-comment">-- |</span><span>
</span><span id="line-4"></span><span class="hs-comment">-- Module      :  Data.Functor.Classes</span><span>
</span><span id="line-5"></span><span class="hs-comment">-- Copyright   :  (c) Ross Paterson 2013</span><span>
</span><span id="line-6"></span><span class="hs-comment">-- License     :  BSD-style (see the file LICENSE)</span><span>
</span><span id="line-7"></span><span class="hs-comment">--</span><span>
</span><span id="line-8"></span><span class="hs-comment">-- Maintainer  :  libraries@haskell.org</span><span>
</span><span id="line-9"></span><span class="hs-comment">-- Stability   :  experimental</span><span>
</span><span id="line-10"></span><span class="hs-comment">-- Portability :  portable</span><span>
</span><span id="line-11"></span><span class="hs-comment">--</span><span>
</span><span id="line-12"></span><span class="hs-comment">-- Liftings of the Prelude classes 'Eq', 'Ord', 'Read' and 'Show' to</span><span>
</span><span id="line-13"></span><span class="hs-comment">-- unary and binary type constructors.</span><span>
</span><span id="line-14"></span><span class="hs-comment">--</span><span>
</span><span id="line-15"></span><span class="hs-comment">-- These classes are needed to express the constraints on arguments of</span><span>
</span><span id="line-16"></span><span class="hs-comment">-- transformers in portable Haskell.  Thus for a new transformer @T@,</span><span>
</span><span id="line-17"></span><span class="hs-comment">-- one might write instances like</span><span>
</span><span id="line-18"></span><span class="hs-comment">--</span><span>
</span><span id="line-19"></span><span class="hs-comment">-- &gt; instance (Eq1 f) =&gt; Eq1 (T f) where ...</span><span>
</span><span id="line-20"></span><span class="hs-comment">-- &gt; instance (Ord1 f) =&gt; Ord1 (T f) where ...</span><span>
</span><span id="line-21"></span><span class="hs-comment">-- &gt; instance (Read1 f) =&gt; Read1 (T f) where ...</span><span>
</span><span id="line-22"></span><span class="hs-comment">-- &gt; instance (Show1 f) =&gt; Show1 (T f) where ...</span><span>
</span><span id="line-23"></span><span class="hs-comment">--</span><span>
</span><span id="line-24"></span><span class="hs-comment">-- If these instances can be defined, defining instances of the base</span><span>
</span><span id="line-25"></span><span class="hs-comment">-- classes is mechanical:</span><span>
</span><span id="line-26"></span><span class="hs-comment">--</span><span>
</span><span id="line-27"></span><span class="hs-comment">-- &gt; instance (Eq1 f, Eq a) =&gt; Eq (T f a) where (==) = eq1</span><span>
</span><span id="line-28"></span><span class="hs-comment">-- &gt; instance (Ord1 f, Ord a) =&gt; Ord (T f a) where compare = compare1</span><span>
</span><span id="line-29"></span><span class="hs-comment">-- &gt; instance (Read1 f, Read a) =&gt; Read (T f a) where</span><span>
</span><span id="line-30"></span><span class="hs-comment">-- &gt;   readPrec     = readPrec1</span><span>
</span><span id="line-31"></span><span class="hs-comment">-- &gt;   readListPrec = readListPrecDefault</span><span>
</span><span id="line-32"></span><span class="hs-comment">-- &gt; instance (Show1 f, Show a) =&gt; Show (T f a) where showsPrec = showsPrec1</span><span>
</span><span id="line-33"></span><span class="hs-comment">--</span><span>
</span><span id="line-34"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-35"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-36"></span><span>
</span><span id="line-37"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">Data.Functor.Classes</span><span> </span><span class="hs-special">(</span><span>
</span><span id="line-38"></span><span>    </span><span class="annot"><span class="hs-comment">-- * Liftings of Prelude classes</span></span><span>
</span><span id="line-39"></span><span>    </span><span class="annot"><span class="hs-comment">-- ** For unary constructors</span></span><span>
</span><span id="line-40"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#Eq1"><span class="hs-identifier">Eq1</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#eq1"><span class="hs-identifier">eq1</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-41"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#Ord1"><span class="hs-identifier">Ord1</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#compare1"><span class="hs-identifier">compare1</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-42"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#Read1"><span class="hs-identifier">Read1</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#readsPrec1"><span class="hs-identifier">readsPrec1</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#readPrec1"><span class="hs-identifier">readPrec1</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-43"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftReadListDefault"><span class="hs-identifier">liftReadListDefault</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#liftReadListPrecDefault"><span class="hs-identifier">liftReadListPrecDefault</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-44"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#Show1"><span class="hs-identifier">Show1</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#showsPrec1"><span class="hs-identifier">showsPrec1</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-45"></span><span>    </span><span class="annot"><span class="hs-comment">-- ** For binary constructors</span></span><span>
</span><span id="line-46"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#Eq2"><span class="hs-identifier">Eq2</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#eq2"><span class="hs-identifier">eq2</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-47"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#Ord2"><span class="hs-identifier">Ord2</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#compare2"><span class="hs-identifier">compare2</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-48"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#Read2"><span class="hs-identifier">Read2</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#readsPrec2"><span class="hs-identifier">readsPrec2</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#readPrec2"><span class="hs-identifier">readPrec2</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-49"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftReadList2Default"><span class="hs-identifier">liftReadList2Default</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#liftReadListPrec2Default"><span class="hs-identifier">liftReadListPrec2Default</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-50"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#Show2"><span class="hs-identifier">Show2</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#showsPrec2"><span class="hs-identifier">showsPrec2</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-51"></span><span>    </span><span class="annot"><span class="hs-comment">-- * Helper functions</span></span><span>
</span><span id="line-52"></span><span>    </span><span class="annot"><span class="hs-comment">-- $example</span></span><span>
</span><span id="line-53"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#readsData"><span class="hs-identifier">readsData</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#readData"><span class="hs-identifier">readData</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-54"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#readsUnaryWith"><span class="hs-identifier">readsUnaryWith</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#readUnaryWith"><span class="hs-identifier">readUnaryWith</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-55"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#readsBinaryWith"><span class="hs-identifier">readsBinaryWith</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#readBinaryWith"><span class="hs-identifier">readBinaryWith</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-56"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#showsUnaryWith"><span class="hs-identifier">showsUnaryWith</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-57"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#showsBinaryWith"><span class="hs-identifier">showsBinaryWith</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-58"></span><span>    </span><span class="annot"><span class="hs-comment">-- ** Obsolete helpers</span></span><span>
</span><span id="line-59"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#readsUnary"><span class="hs-identifier">readsUnary</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-60"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#readsUnary1"><span class="hs-identifier">readsUnary1</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-61"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#readsBinary1"><span class="hs-identifier">readsBinary1</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-62"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#showsUnary"><span class="hs-identifier">showsUnary</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-63"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#showsUnary1"><span class="hs-identifier">showsUnary1</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-64"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#showsBinary1"><span class="hs-identifier">showsBinary1</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-65"></span><span>  </span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-66"></span><span>
</span><span id="line-67"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Control.Applicative.html"><span class="hs-identifier">Control.Applicative</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Base.html#Alternative"><span class="hs-identifier">Alternative</span></a></span><span class="hs-special">(</span><span class="annot"><a href="GHC.Base.html#%3C%7C%3E"><span class="hs-operator">(&lt;|&gt;)</span></a></span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Functor.Const.html#Const"><span class="hs-identifier">Const</span></a></span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Const.html#Const"><span class="hs-identifier">Const</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-68"></span><span>
</span><span id="line-69"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Data.Functor.Identity.html"><span class="hs-identifier">Data.Functor.Identity</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Identity.html#Identity"><span class="hs-identifier">Identity</span></a></span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Identity.html#Identity"><span class="hs-identifier">Identity</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-70"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Data.Proxy.html"><span class="hs-identifier">Data.Proxy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Proxy.html#Proxy"><span class="hs-identifier">Proxy</span></a></span><span class="hs-special">(</span><span class="annot"><a href="Data.Proxy.html#Proxy"><span class="hs-identifier">Proxy</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-71"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Data.List.NonEmpty.html"><span class="hs-identifier">Data.List.NonEmpty</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Base.html#NonEmpty"><span class="hs-identifier">NonEmpty</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-72"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Data.Ord.html"><span class="hs-identifier">Data.Ord</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Ord.html#Down"><span class="hs-identifier">Down</span></a></span><span class="hs-special">(</span><span class="annot"><a href="Data.Ord.html#Down"><span class="hs-identifier">Down</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-73"></span><span>
</span><span id="line-74"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Tuple.html#"><span class="hs-identifier">GHC.Tuple</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Tuple.html#Solo"><span class="hs-identifier">Solo</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-75"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Read.html"><span class="hs-identifier">GHC.Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#expectP"><span class="hs-identifier">expectP</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#list"><span class="hs-identifier">list</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#paren"><span class="hs-identifier">paren</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-76"></span><span>
</span><span id="line-77"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html"><span class="hs-identifier">Text.ParserCombinators.ReadPrec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier">ReadPrec</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier">readPrec_to_S</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier">readS_to_Prec</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-78"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Text.Read.html"><span class="hs-identifier">Text.Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier">Read</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#parens"><span class="hs-identifier">parens</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#prec"><span class="hs-identifier">prec</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#step"><span class="hs-identifier">step</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-79"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Text.Read.Lex.html"><span class="hs-identifier">Text.Read.Lex</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Text.Read.Lex.html#Lexeme"><span class="hs-identifier">Lexeme</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-80"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Text.Show.html"><span class="hs-identifier">Text.Show</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Text.Show.html#showListWith"><span class="hs-identifier">showListWith</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-81"></span><span>
</span><span id="line-82"></span><span class="hs-comment">-- | Lifting of the 'Eq' class to unary type constructors.</span><span>
</span><span id="line-83"></span><span class="hs-comment">--</span><span>
</span><span id="line-84"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-85"></span><span class="hs-keyword">class</span><span> </span><span id="Eq1"><span class="annot"><a href="Data.Functor.Classes.html#Eq1"><span class="hs-identifier hs-var">Eq1</span></a></span></span><span> </span><span id="local-6989586621679569178"><span class="annot"><a href="#local-6989586621679569178"><span class="hs-identifier hs-type">f</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-86"></span><span>    </span><span class="hs-comment">-- | Lift an equality test through the type constructor.</span><span>
</span><span id="line-87"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-88"></span><span>    </span><span class="hs-comment">-- The function will usually be applied to an equality function,</span><span>
</span><span id="line-89"></span><span>    </span><span class="hs-comment">-- but the more general type ensures that the implementation uses</span><span>
</span><span id="line-90"></span><span>    </span><span class="hs-comment">-- it to compare elements of the first container with elements of</span><span>
</span><span id="line-91"></span><span>    </span><span class="hs-comment">-- the second.</span><span>
</span><span id="line-92"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-93"></span><span>    </span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-94"></span><span>    </span><span id="local-6989586621679569176"><span id="local-6989586621679569177"><span id="liftEq"><span class="annot"><a href="Data.Functor.Classes.html#liftEq"><span class="hs-identifier hs-type">liftEq</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679569177"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569176"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Bool"><span class="hs-identifier hs-type">Bool</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569178"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569177"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569178"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569176"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Bool"><span class="hs-identifier hs-type">Bool</span></a></span></span></span><span>
</span><span id="line-95"></span><span>
</span><span id="line-96"></span><span class="hs-comment">-- | Lift the standard @('==')@ function through the type constructor.</span><span>
</span><span id="line-97"></span><span class="hs-comment">--</span><span>
</span><span id="line-98"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-99"></span><span id="local-6989586621679569181"><span id="local-6989586621679569183"><span class="annot"><a href="Data.Functor.Classes.html#eq1"><span class="hs-identifier hs-type">eq1</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Classes.html#Eq1"><span class="hs-identifier hs-type">Eq1</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569183"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Classes.html#Eq"><span class="hs-identifier hs-type">Eq</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569181"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569183"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569181"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569183"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569181"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Bool"><span class="hs-identifier hs-type">Bool</span></a></span></span></span><span>
</span><span id="line-100"></span><span id="eq1"><span class="annot"><span class="annottext">eq1 :: forall (f :: * -&gt; *) a. (Eq1 f, Eq a) =&gt; f a -&gt; f a -&gt; Bool
</span><a href="Data.Functor.Classes.html#eq1"><span class="hs-identifier hs-var hs-var">eq1</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; a -&gt; Bool) -&gt; f a -&gt; f a -&gt; Bool
forall (f :: * -&gt; *) a b.
Eq1 f =&gt;
(a -&gt; b -&gt; Bool) -&gt; f a -&gt; f b -&gt; Bool
</span><a href="Data.Functor.Classes.html#liftEq"><span class="hs-identifier hs-var">liftEq</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">(==)</span></a></span><span>
</span><span id="line-101"></span><span>
</span><span id="line-102"></span><span class="hs-comment">-- | Lifting of the 'Ord' class to unary type constructors.</span><span>
</span><span id="line-103"></span><span class="hs-comment">--</span><span>
</span><span id="line-104"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-105"></span><span class="hs-keyword">class</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Classes.html#Eq1"><span class="hs-identifier hs-type">Eq1</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569174"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span id="Ord1"><span class="annot"><a href="Data.Functor.Classes.html#Ord1"><span class="hs-identifier hs-var">Ord1</span></a></span></span><span> </span><span id="local-6989586621679569174"><span class="annot"><a href="#local-6989586621679569174"><span class="hs-identifier hs-type">f</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-106"></span><span>    </span><span class="hs-comment">-- | Lift a 'compare' function through the type constructor.</span><span>
</span><span id="line-107"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-108"></span><span>    </span><span class="hs-comment">-- The function will usually be applied to a comparison function,</span><span>
</span><span id="line-109"></span><span>    </span><span class="hs-comment">-- but the more general type ensures that the implementation uses</span><span>
</span><span id="line-110"></span><span>    </span><span class="hs-comment">-- it to compare elements of the first container with elements of</span><span>
</span><span id="line-111"></span><span>    </span><span class="hs-comment">-- the second.</span><span>
</span><span id="line-112"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-113"></span><span>    </span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-114"></span><span>    </span><span id="local-6989586621679569167"><span id="local-6989586621679569168"><span id="liftCompare"><span class="annot"><a href="Data.Functor.Classes.html#liftCompare"><span class="hs-identifier hs-type">liftCompare</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679569168"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569167"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Ordering"><span class="hs-identifier hs-type">Ordering</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569174"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569168"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569174"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569167"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Ordering"><span class="hs-identifier hs-type">Ordering</span></a></span></span></span><span>
</span><span id="line-115"></span><span>
</span><span id="line-116"></span><span class="hs-comment">-- | Lift the standard 'compare' function through the type constructor.</span><span>
</span><span id="line-117"></span><span class="hs-comment">--</span><span>
</span><span id="line-118"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-119"></span><span id="local-6989586621679569171"><span id="local-6989586621679569172"><span class="annot"><a href="Data.Functor.Classes.html#compare1"><span class="hs-identifier hs-type">compare1</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Classes.html#Ord1"><span class="hs-identifier hs-type">Ord1</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569172"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Classes.html#Ord"><span class="hs-identifier hs-type">Ord</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569171"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569172"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569171"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569172"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569171"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Ordering"><span class="hs-identifier hs-type">Ordering</span></a></span></span></span><span>
</span><span id="line-120"></span><span id="compare1"><span class="annot"><span class="annottext">compare1 :: forall (f :: * -&gt; *) a. (Ord1 f, Ord a) =&gt; f a -&gt; f a -&gt; Ordering
</span><a href="Data.Functor.Classes.html#compare1"><span class="hs-identifier hs-var hs-var">compare1</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; a -&gt; Ordering) -&gt; f a -&gt; f a -&gt; Ordering
forall (f :: * -&gt; *) a b.
Ord1 f =&gt;
(a -&gt; b -&gt; Ordering) -&gt; f a -&gt; f b -&gt; Ordering
</span><a href="Data.Functor.Classes.html#liftCompare"><span class="hs-identifier hs-var">liftCompare</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Ordering
forall a. Ord a =&gt; a -&gt; a -&gt; Ordering
</span><a href="../../ghc-prim/src/GHC.Classes.html#compare"><span class="hs-identifier hs-var">compare</span></a></span><span>
</span><span id="line-121"></span><span>
</span><span id="line-122"></span><span class="hs-comment">-- | Lifting of the 'Read' class to unary type constructors.</span><span>
</span><span id="line-123"></span><span class="hs-comment">--</span><span>
</span><span id="line-124"></span><span class="hs-comment">-- Both 'liftReadsPrec' and 'liftReadPrec' exist to match the interface</span><span>
</span><span id="line-125"></span><span class="hs-comment">-- provided in the 'Read' type class, but it is recommended to implement</span><span>
</span><span id="line-126"></span><span class="hs-comment">-- 'Read1' instances using 'liftReadPrec' as opposed to 'liftReadsPrec', since</span><span>
</span><span id="line-127"></span><span class="hs-comment">-- the former is more efficient than the latter. For example:</span><span>
</span><span id="line-128"></span><span class="hs-comment">--</span><span>
</span><span id="line-129"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-130"></span><span class="hs-comment">-- instance 'Read1' T where</span><span>
</span><span id="line-131"></span><span class="hs-comment">--   'liftReadPrec'     = ...</span><span>
</span><span id="line-132"></span><span class="hs-comment">--   'liftReadListPrec' = 'liftReadListPrecDefault'</span><span>
</span><span id="line-133"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-134"></span><span class="hs-comment">--</span><span>
</span><span id="line-135"></span><span class="hs-comment">-- For more information, refer to the documentation for the 'Read' class.</span><span>
</span><span id="line-136"></span><span class="hs-comment">--</span><span>
</span><span id="line-137"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-138"></span><span class="hs-keyword">class</span><span> </span><span id="Read1"><span class="annot"><a href="Data.Functor.Classes.html#Read1"><span class="hs-identifier hs-var">Read1</span></a></span></span><span> </span><span id="local-6989586621679569163"><span class="annot"><a href="#local-6989586621679569163"><span class="hs-identifier hs-type">f</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-139"></span><span>    </span><span class="hs-pragma">{-# MINIMAL</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#liftReadsPrec"><span class="hs-pragma hs-type">liftReadsPrec</span></a></span><span> </span><span class="hs-pragma">|</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#liftReadPrec"><span class="hs-pragma hs-type">liftReadPrec</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-140"></span><span>
</span><span id="line-141"></span><span>    </span><span class="hs-comment">-- | 'readsPrec' function for an application of the type constructor</span><span>
</span><span id="line-142"></span><span>    </span><span class="hs-comment">-- based on 'readsPrec' and 'readList' functions for the argument type.</span><span>
</span><span id="line-143"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-144"></span><span>    </span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-145"></span><span>    </span><span id="local-6989586621679569165"><span id="liftReadsPrec"><span class="annot"><a href="Data.Functor.Classes.html#liftReadsPrec"><span class="hs-identifier hs-type">liftReadsPrec</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569165"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569165"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679569163"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569165"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-146"></span><span>    </span><span id="local-6989586621679568691"><span class="annot"><a href="Data.Functor.Classes.html#liftReadsPrec"><span class="hs-identifier hs-var hs-var">liftReadsPrec</span></a></span><span> </span><span id="local-6989586621679568689"><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679568689"><span class="hs-identifier hs-var">rp</span></a></span></span><span> </span><span id="local-6989586621679568688"><span class="annot"><span class="annottext">ReadS [a]
</span><a href="#local-6989586621679568688"><span class="hs-identifier hs-var">rl</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (f a) -&gt; Int -&gt; ReadS (f a)
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span> </span><span class="annot"><span class="annottext">(ReadPrec (f a) -&gt; Int -&gt; ReadS (f a))
-&gt; ReadPrec (f a) -&gt; Int -&gt; ReadS (f a)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-147"></span><span>        </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec (f a)
forall (f :: * -&gt; *) a.
Read1 f =&gt;
ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec (f a)
</span><a href="Data.Functor.Classes.html#liftReadPrec"><span class="hs-identifier hs-var">liftReadPrec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; ReadS a) -&gt; ReadPrec a
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679568689"><span class="hs-identifier hs-var">rp</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; ReadS [a]) -&gt; ReadPrec [a]
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadS [a] -&gt; Int -&gt; ReadS [a]
forall a b. a -&gt; b -&gt; a
</span><a href="GHC.Base.html#const"><span class="hs-identifier hs-var">const</span></a></span><span> </span><span class="annot"><span class="annottext">ReadS [a]
</span><a href="#local-6989586621679568688"><span class="hs-identifier hs-var">rl</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span></span><span>
</span><span id="line-148"></span><span>
</span><span id="line-149"></span><span>    </span><span class="hs-comment">-- | 'readList' function for an application of the type constructor</span><span>
</span><span id="line-150"></span><span>    </span><span class="hs-comment">-- based on 'readsPrec' and 'readList' functions for the argument type.</span><span>
</span><span id="line-151"></span><span>    </span><span class="hs-comment">-- The default implementation using standard list syntax is correct</span><span>
</span><span id="line-152"></span><span>    </span><span class="hs-comment">-- for most types.</span><span>
</span><span id="line-153"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-154"></span><span>    </span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-155"></span><span>    </span><span id="local-6989586621679569152"><span id="liftReadList"><span class="annot"><a href="Data.Functor.Classes.html#liftReadList"><span class="hs-identifier hs-type">liftReadList</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569152"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569152"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569163"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569152"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span></span><span>
</span><span id="line-156"></span><span>    </span><span id="local-6989586621679568685"><span class="annot"><a href="Data.Functor.Classes.html#liftReadList"><span class="hs-identifier hs-var hs-var">liftReadList</span></a></span><span> </span><span id="local-6989586621679568683"><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679568683"><span class="hs-identifier hs-var">rp</span></a></span></span><span> </span><span id="local-6989586621679568682"><span class="annot"><span class="annottext">ReadS [a]
</span><a href="#local-6989586621679568682"><span class="hs-identifier hs-var">rl</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [f a] -&gt; Int -&gt; ReadS [f a]
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span>
</span><span id="line-157"></span><span>        </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec (f a) -&gt; ReadPrec [f a]
forall a. ReadPrec a -&gt; ReadPrec [a]
</span><a href="GHC.Read.html#list"><span class="hs-identifier hs-var">list</span></a></span><span> </span><span class="annot"><span class="annottext">(ReadPrec (f a) -&gt; ReadPrec [f a])
-&gt; ReadPrec (f a) -&gt; ReadPrec [f a]
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec (f a)
forall (f :: * -&gt; *) a.
Read1 f =&gt;
ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec (f a)
</span><a href="Data.Functor.Classes.html#liftReadPrec"><span class="hs-identifier hs-var">liftReadPrec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; ReadS a) -&gt; ReadPrec a
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679568683"><span class="hs-identifier hs-var">rp</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; ReadS [a]) -&gt; ReadPrec [a]
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadS [a] -&gt; Int -&gt; ReadS [a]
forall a b. a -&gt; b -&gt; a
</span><a href="GHC.Base.html#const"><span class="hs-identifier hs-var">const</span></a></span><span> </span><span class="annot"><span class="annottext">ReadS [a]
</span><a href="#local-6989586621679568682"><span class="hs-identifier hs-var">rl</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span></span><span>
</span><span id="line-158"></span><span>
</span><span id="line-159"></span><span>    </span><span class="hs-comment">-- | 'readPrec' function for an application of the type constructor</span><span>
</span><span id="line-160"></span><span>    </span><span class="hs-comment">-- based on 'readPrec' and 'readListPrec' functions for the argument type.</span><span>
</span><span id="line-161"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-162"></span><span>    </span><span class="hs-comment">-- @since 4.10.0.0</span><span>
</span><span id="line-163"></span><span>    </span><span id="local-6989586621679569156"><span id="liftReadPrec"><span class="annot"><a href="Data.Functor.Classes.html#liftReadPrec"><span class="hs-identifier hs-type">liftReadPrec</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569156"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569156"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679569163"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569156"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-164"></span><span>    </span><span id="local-6989586621679568681"><span class="annot"><a href="Data.Functor.Classes.html#liftReadPrec"><span class="hs-identifier hs-var hs-var">liftReadPrec</span></a></span><span> </span><span id="local-6989586621679568679"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568679"><span class="hs-identifier hs-var">rp</span></a></span></span><span> </span><span id="local-6989586621679568678"><span class="annot"><span class="annottext">ReadPrec [a]
</span><a href="#local-6989586621679568678"><span class="hs-identifier hs-var">rl</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; ReadS (f a)) -&gt; ReadPrec (f a)
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="annot"><span class="annottext">((Int -&gt; ReadS (f a)) -&gt; ReadPrec (f a))
-&gt; (Int -&gt; ReadS (f a)) -&gt; ReadPrec (f a)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-165"></span><span>        </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; Int -&gt; ReadS (f a)
forall (f :: * -&gt; *) a.
Read1 f =&gt;
(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; Int -&gt; ReadS (f a)
</span><a href="Data.Functor.Classes.html#liftReadsPrec"><span class="hs-identifier hs-var">liftReadsPrec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec a -&gt; Int -&gt; ReadS a
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568679"><span class="hs-identifier hs-var">rp</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec [a] -&gt; Int -&gt; ReadS [a]
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
</span><a href="#local-6989586621679568678"><span class="hs-identifier hs-var">rl</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span></span><span>
</span><span id="line-166"></span><span>
</span><span id="line-167"></span><span>    </span><span class="hs-comment">-- | 'readListPrec' function for an application of the type constructor</span><span>
</span><span id="line-168"></span><span>    </span><span class="hs-comment">-- based on 'readPrec' and 'readListPrec' functions for the argument type.</span><span>
</span><span id="line-169"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-170"></span><span>    </span><span class="hs-comment">-- The default definition uses 'liftReadList'. Instances that define</span><span>
</span><span id="line-171"></span><span>    </span><span class="hs-comment">-- 'liftReadPrec' should also define 'liftReadListPrec' as</span><span>
</span><span id="line-172"></span><span>    </span><span class="hs-comment">-- 'liftReadListPrecDefault'.</span><span>
</span><span id="line-173"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-174"></span><span>    </span><span class="hs-comment">-- @since 4.10.0.0</span><span>
</span><span id="line-175"></span><span>    </span><span id="local-6989586621679569148"><span id="liftReadListPrec"><span class="annot"><a href="Data.Functor.Classes.html#liftReadListPrec"><span class="hs-identifier hs-type">liftReadListPrec</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569148"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569148"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569163"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569148"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span></span><span>
</span><span id="line-176"></span><span>    </span><span id="local-6989586621679568676"><span class="annot"><a href="Data.Functor.Classes.html#liftReadListPrec"><span class="hs-identifier hs-var hs-var">liftReadListPrec</span></a></span><span> </span><span id="local-6989586621679568674"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568674"><span class="hs-identifier hs-var">rp</span></a></span></span><span> </span><span id="local-6989586621679568673"><span class="annot"><span class="annottext">ReadPrec [a]
</span><a href="#local-6989586621679568673"><span class="hs-identifier hs-var">rl</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; ReadS [f a]) -&gt; ReadPrec [f a]
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="annot"><span class="annottext">((Int -&gt; ReadS [f a]) -&gt; ReadPrec [f a])
-&gt; (Int -&gt; ReadS [f a]) -&gt; ReadPrec [f a]
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="annot"><span class="annottext">Int
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-177"></span><span>        </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [f a]
forall (f :: * -&gt; *) a.
Read1 f =&gt;
(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [f a]
</span><a href="Data.Functor.Classes.html#liftReadList"><span class="hs-identifier hs-var">liftReadList</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec a -&gt; Int -&gt; ReadS a
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568674"><span class="hs-identifier hs-var">rp</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec [a] -&gt; Int -&gt; ReadS [a]
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
</span><a href="#local-6989586621679568673"><span class="hs-identifier hs-var">rl</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span></span><span>
</span><span id="line-178"></span><span>
</span><span id="line-179"></span><span class="hs-comment">-- | Lift the standard 'readsPrec' and 'readList' functions through the</span><span>
</span><span id="line-180"></span><span class="hs-comment">-- type constructor.</span><span>
</span><span id="line-181"></span><span class="hs-comment">--</span><span>
</span><span id="line-182"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-183"></span><span id="local-6989586621679569145"><span id="local-6989586621679569146"><span class="annot"><a href="Data.Functor.Classes.html#readsPrec1"><span class="hs-identifier hs-type">readsPrec1</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Classes.html#Read1"><span class="hs-identifier hs-type">Read1</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569146"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569145"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679569146"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569145"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span></span><span>
</span><span id="line-184"></span><span id="readsPrec1"><span class="annot"><span class="annottext">readsPrec1 :: forall (f :: * -&gt; *) a. (Read1 f, Read a) =&gt; Int -&gt; ReadS (f a)
</span><a href="Data.Functor.Classes.html#readsPrec1"><span class="hs-identifier hs-var hs-var">readsPrec1</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; Int -&gt; ReadS (f a)
forall (f :: * -&gt; *) a.
Read1 f =&gt;
(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; Int -&gt; ReadS (f a)
</span><a href="Data.Functor.Classes.html#liftReadsPrec"><span class="hs-identifier hs-var">liftReadsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS a
forall a. Read a =&gt; Int -&gt; ReadS a
</span><a href="GHC.Read.html#readsPrec"><span class="hs-identifier hs-var">readsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">ReadS [a]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readList"><span class="hs-identifier hs-var">readList</span></a></span><span>
</span><span id="line-185"></span><span>
</span><span id="line-186"></span><span class="hs-comment">-- | Lift the standard 'readPrec' and 'readListPrec' functions through the</span><span>
</span><span id="line-187"></span><span class="hs-comment">-- type constructor.</span><span>
</span><span id="line-188"></span><span class="hs-comment">--</span><span>
</span><span id="line-189"></span><span class="hs-comment">-- @since 4.10.0.0</span><span>
</span><span id="line-190"></span><span id="local-6989586621679569140"><span id="local-6989586621679569141"><span class="annot"><a href="Data.Functor.Classes.html#readPrec1"><span class="hs-identifier hs-type">readPrec1</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Classes.html#Read1"><span class="hs-identifier hs-type">Read1</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569141"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569140"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679569141"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569140"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span></span><span>
</span><span id="line-191"></span><span id="readPrec1"><span class="annot"><span class="annottext">readPrec1 :: forall (f :: * -&gt; *) a. (Read1 f, Read a) =&gt; ReadPrec (f a)
</span><a href="Data.Functor.Classes.html#readPrec1"><span class="hs-identifier hs-var hs-var">readPrec1</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec (f a)
forall (f :: * -&gt; *) a.
Read1 f =&gt;
ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec (f a)
</span><a href="Data.Functor.Classes.html#liftReadPrec"><span class="hs-identifier hs-var">liftReadPrec</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrec"><span class="hs-identifier hs-var">readListPrec</span></a></span><span>
</span><span id="line-192"></span><span>
</span><span id="line-193"></span><span class="hs-comment">-- | A possible replacement definition for the 'liftReadList' method.</span><span>
</span><span id="line-194"></span><span class="hs-comment">-- This is only needed for 'Read1' instances where 'liftReadListPrec' isn't</span><span>
</span><span id="line-195"></span><span class="hs-comment">-- defined as 'liftReadListPrecDefault'.</span><span>
</span><span id="line-196"></span><span class="hs-comment">--</span><span>
</span><span id="line-197"></span><span class="hs-comment">-- @since 4.10.0.0</span><span>
</span><span id="line-198"></span><span id="local-6989586621679569136"><span id="local-6989586621679569137"><span class="annot"><a href="Data.Functor.Classes.html#liftReadListDefault"><span class="hs-identifier hs-type">liftReadListDefault</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Read1"><span class="hs-identifier hs-type">Read1</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569137"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569136"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569136"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569137"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569136"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span></span></span><span>
</span><span id="line-199"></span><span id="liftReadListDefault"><span class="annot"><span class="annottext">liftReadListDefault :: forall (f :: * -&gt; *) a.
Read1 f =&gt;
(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [f a]
</span><a href="Data.Functor.Classes.html#liftReadListDefault"><span class="hs-identifier hs-var hs-var">liftReadListDefault</span></a></span></span><span> </span><span id="local-6989586621679568656"><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679568656"><span class="hs-identifier hs-var">rp</span></a></span></span><span> </span><span id="local-6989586621679568655"><span class="annot"><span class="annottext">ReadS [a]
</span><a href="#local-6989586621679568655"><span class="hs-identifier hs-var">rl</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [f a] -&gt; Int -&gt; ReadS [f a]
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span>
</span><span id="line-200"></span><span>    </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [f a]
forall (f :: * -&gt; *) a.
Read1 f =&gt;
ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [f a]
</span><a href="Data.Functor.Classes.html#liftReadListPrec"><span class="hs-identifier hs-var">liftReadListPrec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; ReadS a) -&gt; ReadPrec a
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679568656"><span class="hs-identifier hs-var">rp</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; ReadS [a]) -&gt; ReadPrec [a]
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadS [a] -&gt; Int -&gt; ReadS [a]
forall a b. a -&gt; b -&gt; a
</span><a href="GHC.Base.html#const"><span class="hs-identifier hs-var">const</span></a></span><span> </span><span class="annot"><span class="annottext">ReadS [a]
</span><a href="#local-6989586621679568655"><span class="hs-identifier hs-var">rl</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-201"></span><span>
</span><span id="line-202"></span><span class="hs-comment">-- | A possible replacement definition for the 'liftReadListPrec' method,</span><span>
</span><span id="line-203"></span><span class="hs-comment">-- defined using 'liftReadPrec'.</span><span>
</span><span id="line-204"></span><span class="hs-comment">--</span><span>
</span><span id="line-205"></span><span class="hs-comment">-- @since 4.10.0.0</span><span>
</span><span id="line-206"></span><span id="local-6989586621679569132"><span id="local-6989586621679569133"><span class="annot"><a href="Data.Functor.Classes.html#liftReadListPrecDefault"><span class="hs-identifier hs-type">liftReadListPrecDefault</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Read1"><span class="hs-identifier hs-type">Read1</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569133"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569132"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569132"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-207"></span><span>                        </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569133"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569132"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span></span></span><span>
</span><span id="line-208"></span><span id="liftReadListPrecDefault"><span class="annot"><span class="annottext">liftReadListPrecDefault :: forall (f :: * -&gt; *) a.
Read1 f =&gt;
ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [f a]
</span><a href="Data.Functor.Classes.html#liftReadListPrecDefault"><span class="hs-identifier hs-var hs-var">liftReadListPrecDefault</span></a></span></span><span> </span><span id="local-6989586621679568652"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568652"><span class="hs-identifier hs-var">rp</span></a></span></span><span> </span><span id="local-6989586621679568651"><span class="annot"><span class="annottext">ReadPrec [a]
</span><a href="#local-6989586621679568651"><span class="hs-identifier hs-var">rl</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (f a) -&gt; ReadPrec [f a]
forall a. ReadPrec a -&gt; ReadPrec [a]
</span><a href="GHC.Read.html#list"><span class="hs-identifier hs-var">list</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec (f a)
forall (f :: * -&gt; *) a.
Read1 f =&gt;
ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec (f a)
</span><a href="Data.Functor.Classes.html#liftReadPrec"><span class="hs-identifier hs-var">liftReadPrec</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568652"><span class="hs-identifier hs-var">rp</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
</span><a href="#local-6989586621679568651"><span class="hs-identifier hs-var">rl</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-209"></span><span>
</span><span id="line-210"></span><span class="hs-comment">-- | Lifting of the 'Show' class to unary type constructors.</span><span>
</span><span id="line-211"></span><span class="hs-comment">--</span><span>
</span><span id="line-212"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-213"></span><span class="hs-keyword">class</span><span> </span><span id="Show1"><span class="annot"><a href="Data.Functor.Classes.html#Show1"><span class="hs-identifier hs-var">Show1</span></a></span></span><span> </span><span id="local-6989586621679569127"><span class="annot"><a href="#local-6989586621679569127"><span class="hs-identifier hs-type">f</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-214"></span><span>    </span><span class="hs-comment">-- | 'showsPrec' function for an application of the type constructor</span><span>
</span><span id="line-215"></span><span>    </span><span class="hs-comment">-- based on 'showsPrec' and 'showList' functions for the argument type.</span><span>
</span><span id="line-216"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-217"></span><span>    </span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-218"></span><span>    </span><span id="local-6989586621679569124"><span id="liftShowsPrec"><span class="annot"><a href="Data.Functor.Classes.html#liftShowsPrec"><span class="hs-identifier hs-type">liftShowsPrec</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569124"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569124"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-219"></span><span>        </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569127"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569124"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span></span><span>
</span><span id="line-220"></span><span>
</span><span id="line-221"></span><span>    </span><span class="hs-comment">-- | 'showList' function for an application of the type constructor</span><span>
</span><span id="line-222"></span><span>    </span><span class="hs-comment">-- based on 'showsPrec' and 'showList' functions for the argument type.</span><span>
</span><span id="line-223"></span><span>    </span><span class="hs-comment">-- The default implementation using standard list syntax is correct</span><span>
</span><span id="line-224"></span><span>    </span><span class="hs-comment">-- for most types.</span><span>
</span><span id="line-225"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-226"></span><span>    </span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-227"></span><span>    </span><span id="local-6989586621679569129"><span id="liftShowList"><span class="annot"><a href="Data.Functor.Classes.html#liftShowList"><span class="hs-identifier hs-type">liftShowList</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569129"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569129"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-228"></span><span>        </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569127"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569129"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span></span><span>
</span><span id="line-229"></span><span>    </span><span id="local-6989586621679568647"><span class="annot"><a href="Data.Functor.Classes.html#liftShowList"><span class="hs-identifier hs-var hs-var">liftShowList</span></a></span><span> </span><span id="local-6989586621679568645"><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679568645"><span class="hs-identifier hs-var">sp</span></a></span></span><span> </span><span id="local-6989586621679568644"><span class="annot"><span class="annottext">[a] -&gt; ShowS
</span><a href="#local-6989586621679568644"><span class="hs-identifier hs-var">sl</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(f a -&gt; ShowS) -&gt; [f a] -&gt; ShowS
forall a. (a -&gt; ShowS) -&gt; [a] -&gt; ShowS
</span><a href="Text.Show.html#showListWith"><span class="hs-identifier hs-var">showListWith</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; a -&gt; ShowS) -&gt; ([a] -&gt; ShowS) -&gt; Int -&gt; f a -&gt; ShowS
forall (f :: * -&gt; *) a.
Show1 f =&gt;
(Int -&gt; a -&gt; ShowS) -&gt; ([a] -&gt; ShowS) -&gt; Int -&gt; f a -&gt; ShowS
</span><a href="Data.Functor.Classes.html#liftShowsPrec"><span class="hs-identifier hs-var">liftShowsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679568645"><span class="hs-identifier hs-var">sp</span></a></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
</span><a href="#local-6989586621679568644"><span class="hs-identifier hs-var">sl</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span></span><span>
</span><span id="line-230"></span><span>
</span><span id="line-231"></span><span class="hs-comment">-- | Lift the standard 'showsPrec' and 'showList' functions through the</span><span>
</span><span id="line-232"></span><span class="hs-comment">-- type constructor.</span><span>
</span><span id="line-233"></span><span class="hs-comment">--</span><span>
</span><span id="line-234"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-235"></span><span id="local-6989586621679569122"><span id="local-6989586621679569123"><span class="annot"><a href="Data.Functor.Classes.html#showsPrec1"><span class="hs-identifier hs-type">showsPrec1</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Classes.html#Show1"><span class="hs-identifier hs-type">Show1</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569123"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Show.html#Show"><span class="hs-identifier hs-type">Show</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569122"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569123"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569122"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span></span></span><span>
</span><span id="line-236"></span><span id="showsPrec1"><span class="annot"><span class="annottext">showsPrec1 :: forall (f :: * -&gt; *) a. (Show1 f, Show a) =&gt; Int -&gt; f a -&gt; ShowS
</span><a href="Data.Functor.Classes.html#showsPrec1"><span class="hs-identifier hs-var hs-var">showsPrec1</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; a -&gt; ShowS) -&gt; ([a] -&gt; ShowS) -&gt; Int -&gt; f a -&gt; ShowS
forall (f :: * -&gt; *) a.
Show1 f =&gt;
(Int -&gt; a -&gt; ShowS) -&gt; ([a] -&gt; ShowS) -&gt; Int -&gt; f a -&gt; ShowS
</span><a href="Data.Functor.Classes.html#liftShowsPrec"><span class="hs-identifier hs-var">liftShowsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
forall a. Show a =&gt; Int -&gt; a -&gt; ShowS
</span><a href="GHC.Show.html#showsPrec"><span class="hs-identifier hs-var">showsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
forall a. Show a =&gt; [a] -&gt; ShowS
</span><a href="GHC.Show.html#showList"><span class="hs-identifier hs-var">showList</span></a></span><span>
</span><span id="line-237"></span><span>
</span><span id="line-238"></span><span class="hs-comment">-- | Lifting of the 'Eq' class to binary type constructors.</span><span>
</span><span id="line-239"></span><span class="hs-comment">--</span><span>
</span><span id="line-240"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-241"></span><span class="hs-keyword">class</span><span> </span><span id="Eq2"><span class="annot"><a href="Data.Functor.Classes.html#Eq2"><span class="hs-identifier hs-var">Eq2</span></a></span></span><span> </span><span id="local-6989586621679569111"><span class="annot"><a href="#local-6989586621679569111"><span class="hs-identifier hs-type">f</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-242"></span><span>    </span><span class="hs-comment">-- | Lift equality tests through the type constructor.</span><span>
</span><span id="line-243"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-244"></span><span>    </span><span class="hs-comment">-- The function will usually be applied to equality functions,</span><span>
</span><span id="line-245"></span><span>    </span><span class="hs-comment">-- but the more general type ensures that the implementation uses</span><span>
</span><span id="line-246"></span><span>    </span><span class="hs-comment">-- them to compare elements of the first container with elements of</span><span>
</span><span id="line-247"></span><span>    </span><span class="hs-comment">-- the second.</span><span>
</span><span id="line-248"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-249"></span><span>    </span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-250"></span><span>    </span><span id="local-6989586621679569107"><span id="local-6989586621679569108"><span id="local-6989586621679569109"><span id="local-6989586621679569110"><span id="liftEq2"><span class="annot"><a href="Data.Functor.Classes.html#liftEq2"><span class="hs-identifier hs-type">liftEq2</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679569110"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569109"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Bool"><span class="hs-identifier hs-type">Bool</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679569108"><span class="hs-identifier hs-type">c</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569107"><span class="hs-identifier hs-type">d</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Bool"><span class="hs-identifier hs-type">Bool</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569111"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569110"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569108"><span class="hs-identifier hs-type">c</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569111"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569109"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569107"><span class="hs-identifier hs-type">d</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Bool"><span class="hs-identifier hs-type">Bool</span></a></span></span></span></span></span><span>
</span><span id="line-251"></span><span>
</span><span id="line-252"></span><span class="hs-comment">-- | Lift the standard @('==')@ function through the type constructor.</span><span>
</span><span id="line-253"></span><span class="hs-comment">--</span><span>
</span><span id="line-254"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-255"></span><span id="local-6989586621679569115"><span id="local-6989586621679569116"><span id="local-6989586621679569118"><span class="annot"><a href="Data.Functor.Classes.html#eq2"><span class="hs-identifier hs-type">eq2</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Classes.html#Eq2"><span class="hs-identifier hs-type">Eq2</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569118"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Classes.html#Eq"><span class="hs-identifier hs-type">Eq</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569116"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Classes.html#Eq"><span class="hs-identifier hs-type">Eq</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569115"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569118"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569116"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569115"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569118"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569116"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569115"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Bool"><span class="hs-identifier hs-type">Bool</span></a></span></span></span></span><span>
</span><span id="line-256"></span><span id="eq2"><span class="annot"><span class="annottext">eq2 :: forall (f :: * -&gt; * -&gt; *) a b.
(Eq2 f, Eq a, Eq b) =&gt;
f a b -&gt; f a b -&gt; Bool
</span><a href="Data.Functor.Classes.html#eq2"><span class="hs-identifier hs-var hs-var">eq2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; a -&gt; Bool) -&gt; (b -&gt; b -&gt; Bool) -&gt; f a b -&gt; f a b -&gt; Bool
forall (f :: * -&gt; * -&gt; *) a b c d.
Eq2 f =&gt;
(a -&gt; b -&gt; Bool) -&gt; (c -&gt; d -&gt; Bool) -&gt; f a c -&gt; f b d -&gt; Bool
</span><a href="Data.Functor.Classes.html#liftEq2"><span class="hs-identifier hs-var">liftEq2</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">(==)</span></a></span><span> </span><span class="annot"><span class="annottext">b -&gt; b -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">(==)</span></a></span><span>
</span><span id="line-257"></span><span>
</span><span id="line-258"></span><span class="hs-comment">-- | Lifting of the 'Ord' class to binary type constructors.</span><span>
</span><span id="line-259"></span><span class="hs-comment">--</span><span>
</span><span id="line-260"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-261"></span><span class="hs-keyword">class</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Classes.html#Eq2"><span class="hs-identifier hs-type">Eq2</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569106"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span id="Ord2"><span class="annot"><a href="Data.Functor.Classes.html#Ord2"><span class="hs-identifier hs-var">Ord2</span></a></span></span><span> </span><span id="local-6989586621679569106"><span class="annot"><a href="#local-6989586621679569106"><span class="hs-identifier hs-type">f</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-262"></span><span>    </span><span class="hs-comment">-- | Lift 'compare' functions through the type constructor.</span><span>
</span><span id="line-263"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-264"></span><span>    </span><span class="hs-comment">-- The function will usually be applied to comparison functions,</span><span>
</span><span id="line-265"></span><span>    </span><span class="hs-comment">-- but the more general type ensures that the implementation uses</span><span>
</span><span id="line-266"></span><span>    </span><span class="hs-comment">-- them to compare elements of the first container with elements of</span><span>
</span><span id="line-267"></span><span>    </span><span class="hs-comment">-- the second.</span><span>
</span><span id="line-268"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-269"></span><span>    </span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-270"></span><span>    </span><span id="local-6989586621679569095"><span id="local-6989586621679569096"><span id="local-6989586621679569097"><span id="local-6989586621679569098"><span id="liftCompare2"><span class="annot"><a href="Data.Functor.Classes.html#liftCompare2"><span class="hs-identifier hs-type">liftCompare2</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679569098"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569097"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Ordering"><span class="hs-identifier hs-type">Ordering</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679569096"><span class="hs-identifier hs-type">c</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569095"><span class="hs-identifier hs-type">d</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Ordering"><span class="hs-identifier hs-type">Ordering</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-271"></span><span>        </span><span class="annot"><a href="#local-6989586621679569106"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569098"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569096"><span class="hs-identifier hs-type">c</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569106"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569097"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569095"><span class="hs-identifier hs-type">d</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Ordering"><span class="hs-identifier hs-type">Ordering</span></a></span></span></span></span></span><span>
</span><span id="line-272"></span><span>
</span><span id="line-273"></span><span class="hs-comment">-- | Lift the standard 'compare' function through the type constructor.</span><span>
</span><span id="line-274"></span><span class="hs-comment">--</span><span>
</span><span id="line-275"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-276"></span><span id="local-6989586621679569102"><span id="local-6989586621679569103"><span id="local-6989586621679569104"><span class="annot"><a href="Data.Functor.Classes.html#compare2"><span class="hs-identifier hs-type">compare2</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Classes.html#Ord2"><span class="hs-identifier hs-type">Ord2</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569104"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Classes.html#Ord"><span class="hs-identifier hs-type">Ord</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569103"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Classes.html#Ord"><span class="hs-identifier hs-type">Ord</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569102"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569104"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569103"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569102"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569104"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569103"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569102"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Ordering"><span class="hs-identifier hs-type">Ordering</span></a></span></span></span></span><span>
</span><span id="line-277"></span><span id="compare2"><span class="annot"><span class="annottext">compare2 :: forall (f :: * -&gt; * -&gt; *) a b.
(Ord2 f, Ord a, Ord b) =&gt;
f a b -&gt; f a b -&gt; Ordering
</span><a href="Data.Functor.Classes.html#compare2"><span class="hs-identifier hs-var hs-var">compare2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; a -&gt; Ordering)
-&gt; (b -&gt; b -&gt; Ordering) -&gt; f a b -&gt; f a b -&gt; Ordering
forall (f :: * -&gt; * -&gt; *) a b c d.
Ord2 f =&gt;
(a -&gt; b -&gt; Ordering)
-&gt; (c -&gt; d -&gt; Ordering) -&gt; f a c -&gt; f b d -&gt; Ordering
</span><a href="Data.Functor.Classes.html#liftCompare2"><span class="hs-identifier hs-var">liftCompare2</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Ordering
forall a. Ord a =&gt; a -&gt; a -&gt; Ordering
</span><a href="../../ghc-prim/src/GHC.Classes.html#compare"><span class="hs-identifier hs-var">compare</span></a></span><span> </span><span class="annot"><span class="annottext">b -&gt; b -&gt; Ordering
forall a. Ord a =&gt; a -&gt; a -&gt; Ordering
</span><a href="../../ghc-prim/src/GHC.Classes.html#compare"><span class="hs-identifier hs-var">compare</span></a></span><span>
</span><span id="line-278"></span><span>
</span><span id="line-279"></span><span class="hs-comment">-- | Lifting of the 'Read' class to binary type constructors.</span><span>
</span><span id="line-280"></span><span class="hs-comment">--</span><span>
</span><span id="line-281"></span><span class="hs-comment">-- Both 'liftReadsPrec2' and 'liftReadPrec2' exist to match the interface</span><span>
</span><span id="line-282"></span><span class="hs-comment">-- provided in the 'Read' type class, but it is recommended to implement</span><span>
</span><span id="line-283"></span><span class="hs-comment">-- 'Read2' instances using 'liftReadPrec2' as opposed to 'liftReadsPrec2',</span><span>
</span><span id="line-284"></span><span class="hs-comment">-- since the former is more efficient than the latter. For example:</span><span>
</span><span id="line-285"></span><span class="hs-comment">--</span><span>
</span><span id="line-286"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-287"></span><span class="hs-comment">-- instance 'Read2' T where</span><span>
</span><span id="line-288"></span><span class="hs-comment">--   'liftReadPrec2'     = ...</span><span>
</span><span id="line-289"></span><span class="hs-comment">--   'liftReadListPrec2' = 'liftReadListPrec2Default'</span><span>
</span><span id="line-290"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-291"></span><span class="hs-comment">--</span><span>
</span><span id="line-292"></span><span class="hs-comment">-- For more information, refer to the documentation for the 'Read' class.</span><span>
</span><span id="line-293"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-294"></span><span class="hs-keyword">class</span><span> </span><span id="Read2"><span class="annot"><a href="Data.Functor.Classes.html#Read2"><span class="hs-identifier hs-var">Read2</span></a></span></span><span> </span><span id="local-6989586621679569092"><span class="annot"><a href="#local-6989586621679569092"><span class="hs-identifier hs-type">f</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-295"></span><span>    </span><span class="hs-pragma">{-# MINIMAL</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#liftReadsPrec2"><span class="hs-pragma hs-type">liftReadsPrec2</span></a></span><span> </span><span class="hs-pragma">|</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#liftReadPrec2"><span class="hs-pragma hs-type">liftReadPrec2</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-296"></span><span>
</span><span id="line-297"></span><span>    </span><span class="hs-comment">-- | 'readsPrec' function for an application of the type constructor</span><span>
</span><span id="line-298"></span><span>    </span><span class="hs-comment">-- based on 'readsPrec' and 'readList' functions for the argument types.</span><span>
</span><span id="line-299"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-300"></span><span>    </span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-301"></span><span>    </span><span id="local-6989586621679569093"><span id="local-6989586621679569094"><span id="liftReadsPrec2"><span class="annot"><a href="Data.Functor.Classes.html#liftReadsPrec2"><span class="hs-identifier hs-type">liftReadsPrec2</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569094"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569094"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-302"></span><span>        </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569093"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569093"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679569092"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569094"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569093"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span></span></span><span>
</span><span id="line-303"></span><span>    </span><span id="local-6989586621679568618"><span class="annot"><a href="Data.Functor.Classes.html#liftReadsPrec2"><span class="hs-identifier hs-var hs-var">liftReadsPrec2</span></a></span><span> </span><span id="local-6989586621679568616"><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679568616"><span class="hs-identifier hs-var">rp1</span></a></span></span><span> </span><span id="local-6989586621679568615"><span class="annot"><span class="annottext">ReadS [a]
</span><a href="#local-6989586621679568615"><span class="hs-identifier hs-var">rl1</span></a></span></span><span> </span><span id="local-6989586621679568614"><span class="annot"><span class="annottext">Int -&gt; ReadS b
</span><a href="#local-6989586621679568614"><span class="hs-identifier hs-var">rp2</span></a></span></span><span> </span><span id="local-6989586621679568613"><span class="annot"><span class="annottext">ReadS [b]
</span><a href="#local-6989586621679568613"><span class="hs-identifier hs-var">rl2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (f a b) -&gt; Int -&gt; ReadS (f a b)
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span> </span><span class="annot"><span class="annottext">(ReadPrec (f a b) -&gt; Int -&gt; ReadS (f a b))
-&gt; ReadPrec (f a b) -&gt; Int -&gt; ReadS (f a b)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-304"></span><span>        </span><span class="annot"><span class="annottext">ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec b -&gt; ReadPrec [b] -&gt; ReadPrec (f a b)
forall (f :: * -&gt; * -&gt; *) a b.
Read2 f =&gt;
ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec b -&gt; ReadPrec [b] -&gt; ReadPrec (f a b)
</span><a href="Data.Functor.Classes.html#liftReadPrec2"><span class="hs-identifier hs-var">liftReadPrec2</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; ReadS a) -&gt; ReadPrec a
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679568616"><span class="hs-identifier hs-var">rp1</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; ReadS [a]) -&gt; ReadPrec [a]
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadS [a] -&gt; Int -&gt; ReadS [a]
forall a b. a -&gt; b -&gt; a
</span><a href="GHC.Base.html#const"><span class="hs-identifier hs-var">const</span></a></span><span> </span><span class="annot"><span class="annottext">ReadS [a]
</span><a href="#local-6989586621679568615"><span class="hs-identifier hs-var">rl1</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-305"></span><span>                      </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; ReadS b) -&gt; ReadPrec b
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS b
</span><a href="#local-6989586621679568614"><span class="hs-identifier hs-var">rp2</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; ReadS [b]) -&gt; ReadPrec [b]
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadS [b] -&gt; Int -&gt; ReadS [b]
forall a b. a -&gt; b -&gt; a
</span><a href="GHC.Base.html#const"><span class="hs-identifier hs-var">const</span></a></span><span> </span><span class="annot"><span class="annottext">ReadS [b]
</span><a href="#local-6989586621679568613"><span class="hs-identifier hs-var">rl2</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span></span><span>
</span><span id="line-306"></span><span>
</span><span id="line-307"></span><span>    </span><span class="hs-comment">-- | 'readList' function for an application of the type constructor</span><span>
</span><span id="line-308"></span><span>    </span><span class="hs-comment">-- based on 'readsPrec' and 'readList' functions for the argument types.</span><span>
</span><span id="line-309"></span><span>    </span><span class="hs-comment">-- The default implementation using standard list syntax is correct</span><span>
</span><span id="line-310"></span><span>    </span><span class="hs-comment">-- for most types.</span><span>
</span><span id="line-311"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-312"></span><span>    </span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-313"></span><span>    </span><span id="local-6989586621679569086"><span id="local-6989586621679569087"><span id="liftReadList2"><span class="annot"><a href="Data.Functor.Classes.html#liftReadList2"><span class="hs-identifier hs-type">liftReadList2</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569087"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569087"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-314"></span><span>        </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569086"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569086"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569092"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569087"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569086"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">]</span></span></span><span>
</span><span id="line-315"></span><span>    </span><span id="local-6989586621679568611"><span class="annot"><a href="Data.Functor.Classes.html#liftReadList2"><span class="hs-identifier hs-var hs-var">liftReadList2</span></a></span><span> </span><span id="local-6989586621679568609"><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679568609"><span class="hs-identifier hs-var">rp1</span></a></span></span><span> </span><span id="local-6989586621679568608"><span class="annot"><span class="annottext">ReadS [a]
</span><a href="#local-6989586621679568608"><span class="hs-identifier hs-var">rl1</span></a></span></span><span> </span><span id="local-6989586621679568607"><span class="annot"><span class="annottext">Int -&gt; ReadS b
</span><a href="#local-6989586621679568607"><span class="hs-identifier hs-var">rp2</span></a></span></span><span> </span><span id="local-6989586621679568606"><span class="annot"><span class="annottext">ReadS [b]
</span><a href="#local-6989586621679568606"><span class="hs-identifier hs-var">rl2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [f a b] -&gt; Int -&gt; ReadS [f a b]
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span>
</span><span id="line-316"></span><span>       </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec (f a b) -&gt; ReadPrec [f a b]
forall a. ReadPrec a -&gt; ReadPrec [a]
</span><a href="GHC.Read.html#list"><span class="hs-identifier hs-var">list</span></a></span><span> </span><span class="annot"><span class="annottext">(ReadPrec (f a b) -&gt; ReadPrec [f a b])
-&gt; ReadPrec (f a b) -&gt; ReadPrec [f a b]
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec b -&gt; ReadPrec [b] -&gt; ReadPrec (f a b)
forall (f :: * -&gt; * -&gt; *) a b.
Read2 f =&gt;
ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec b -&gt; ReadPrec [b] -&gt; ReadPrec (f a b)
</span><a href="Data.Functor.Classes.html#liftReadPrec2"><span class="hs-identifier hs-var">liftReadPrec2</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; ReadS a) -&gt; ReadPrec a
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679568609"><span class="hs-identifier hs-var">rp1</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; ReadS [a]) -&gt; ReadPrec [a]
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadS [a] -&gt; Int -&gt; ReadS [a]
forall a b. a -&gt; b -&gt; a
</span><a href="GHC.Base.html#const"><span class="hs-identifier hs-var">const</span></a></span><span> </span><span class="annot"><span class="annottext">ReadS [a]
</span><a href="#local-6989586621679568608"><span class="hs-identifier hs-var">rl1</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-317"></span><span>                             </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; ReadS b) -&gt; ReadPrec b
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS b
</span><a href="#local-6989586621679568607"><span class="hs-identifier hs-var">rp2</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; ReadS [b]) -&gt; ReadPrec [b]
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadS [b] -&gt; Int -&gt; ReadS [b]
forall a b. a -&gt; b -&gt; a
</span><a href="GHC.Base.html#const"><span class="hs-identifier hs-var">const</span></a></span><span> </span><span class="annot"><span class="annottext">ReadS [b]
</span><a href="#local-6989586621679568606"><span class="hs-identifier hs-var">rl2</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span></span><span>
</span><span id="line-318"></span><span>
</span><span id="line-319"></span><span>    </span><span class="hs-comment">-- | 'readPrec' function for an application of the type constructor</span><span>
</span><span id="line-320"></span><span>    </span><span class="hs-comment">-- based on 'readPrec' and 'readListPrec' functions for the argument types.</span><span>
</span><span id="line-321"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-322"></span><span>    </span><span class="hs-comment">-- @since 4.10.0.0</span><span>
</span><span id="line-323"></span><span>    </span><span id="local-6989586621679569088"><span id="local-6989586621679569089"><span id="liftReadPrec2"><span class="annot"><a href="Data.Functor.Classes.html#liftReadPrec2"><span class="hs-identifier hs-type">liftReadPrec2</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569089"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569089"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-324"></span><span>        </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569088"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569088"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679569092"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569089"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569088"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span></span></span><span>
</span><span id="line-325"></span><span>    </span><span id="local-6989586621679568605"><span class="annot"><a href="Data.Functor.Classes.html#liftReadPrec2"><span class="hs-identifier hs-var hs-var">liftReadPrec2</span></a></span><span> </span><span id="local-6989586621679568603"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568603"><span class="hs-identifier hs-var">rp1</span></a></span></span><span> </span><span id="local-6989586621679568602"><span class="annot"><span class="annottext">ReadPrec [a]
</span><a href="#local-6989586621679568602"><span class="hs-identifier hs-var">rl1</span></a></span></span><span> </span><span id="local-6989586621679568601"><span class="annot"><span class="annottext">ReadPrec b
</span><a href="#local-6989586621679568601"><span class="hs-identifier hs-var">rp2</span></a></span></span><span> </span><span id="local-6989586621679568600"><span class="annot"><span class="annottext">ReadPrec [b]
</span><a href="#local-6989586621679568600"><span class="hs-identifier hs-var">rl2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; ReadS (f a b)) -&gt; ReadPrec (f a b)
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="annot"><span class="annottext">((Int -&gt; ReadS (f a b)) -&gt; ReadPrec (f a b))
-&gt; (Int -&gt; ReadS (f a b)) -&gt; ReadPrec (f a b)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-326"></span><span>        </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a)
-&gt; ReadS [a]
-&gt; (Int -&gt; ReadS b)
-&gt; ReadS [b]
-&gt; Int
-&gt; ReadS (f a b)
forall (f :: * -&gt; * -&gt; *) a b.
Read2 f =&gt;
(Int -&gt; ReadS a)
-&gt; ReadS [a]
-&gt; (Int -&gt; ReadS b)
-&gt; ReadS [b]
-&gt; Int
-&gt; ReadS (f a b)
</span><a href="Data.Functor.Classes.html#liftReadsPrec2"><span class="hs-identifier hs-var">liftReadsPrec2</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec a -&gt; Int -&gt; ReadS a
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568603"><span class="hs-identifier hs-var">rp1</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec [a] -&gt; Int -&gt; ReadS [a]
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
</span><a href="#local-6989586621679568602"><span class="hs-identifier hs-var">rl1</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-327"></span><span>                       </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec b -&gt; Int -&gt; ReadS b
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec b
</span><a href="#local-6989586621679568601"><span class="hs-identifier hs-var">rp2</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec [b] -&gt; Int -&gt; ReadS [b]
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec [b]
</span><a href="#local-6989586621679568600"><span class="hs-identifier hs-var">rl2</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span></span><span>
</span><span id="line-328"></span><span>
</span><span id="line-329"></span><span>    </span><span class="hs-comment">-- | 'readListPrec' function for an application of the type constructor</span><span>
</span><span id="line-330"></span><span>    </span><span class="hs-comment">-- based on 'readPrec' and 'readListPrec' functions for the argument types.</span><span>
</span><span id="line-331"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-332"></span><span>    </span><span class="hs-comment">-- The default definition uses 'liftReadList2'. Instances that define</span><span>
</span><span id="line-333"></span><span>    </span><span class="hs-comment">-- 'liftReadPrec2' should also define 'liftReadListPrec2' as</span><span>
</span><span id="line-334"></span><span>    </span><span class="hs-comment">-- 'liftReadListPrec2Default'.</span><span>
</span><span id="line-335"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-336"></span><span>    </span><span class="hs-comment">-- @since 4.10.0.0</span><span>
</span><span id="line-337"></span><span>    </span><span id="local-6989586621679569080"><span id="local-6989586621679569081"><span id="liftReadListPrec2"><span class="annot"><a href="Data.Functor.Classes.html#liftReadListPrec2"><span class="hs-identifier hs-type">liftReadListPrec2</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569081"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569081"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-338"></span><span>        </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569080"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569080"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569092"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569081"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569080"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">]</span></span></span><span>
</span><span id="line-339"></span><span>    </span><span id="local-6989586621679568598"><span class="annot"><a href="Data.Functor.Classes.html#liftReadListPrec2"><span class="hs-identifier hs-var hs-var">liftReadListPrec2</span></a></span><span> </span><span id="local-6989586621679568596"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568596"><span class="hs-identifier hs-var">rp1</span></a></span></span><span> </span><span id="local-6989586621679568595"><span class="annot"><span class="annottext">ReadPrec [a]
</span><a href="#local-6989586621679568595"><span class="hs-identifier hs-var">rl1</span></a></span></span><span> </span><span id="local-6989586621679568594"><span class="annot"><span class="annottext">ReadPrec b
</span><a href="#local-6989586621679568594"><span class="hs-identifier hs-var">rp2</span></a></span></span><span> </span><span id="local-6989586621679568593"><span class="annot"><span class="annottext">ReadPrec [b]
</span><a href="#local-6989586621679568593"><span class="hs-identifier hs-var">rl2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; ReadS [f a b]) -&gt; ReadPrec [f a b]
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="annot"><span class="annottext">((Int -&gt; ReadS [f a b]) -&gt; ReadPrec [f a b])
-&gt; (Int -&gt; ReadS [f a b]) -&gt; ReadPrec [f a b]
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="annot"><span class="annottext">Int
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-340"></span><span>        </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a)
-&gt; ReadS [a] -&gt; (Int -&gt; ReadS b) -&gt; ReadS [b] -&gt; ReadS [f a b]
forall (f :: * -&gt; * -&gt; *) a b.
Read2 f =&gt;
(Int -&gt; ReadS a)
-&gt; ReadS [a] -&gt; (Int -&gt; ReadS b) -&gt; ReadS [b] -&gt; ReadS [f a b]
</span><a href="Data.Functor.Classes.html#liftReadList2"><span class="hs-identifier hs-var">liftReadList2</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec a -&gt; Int -&gt; ReadS a
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568596"><span class="hs-identifier hs-var">rp1</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec [a] -&gt; Int -&gt; ReadS [a]
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
</span><a href="#local-6989586621679568595"><span class="hs-identifier hs-var">rl1</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-341"></span><span>                      </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec b -&gt; Int -&gt; ReadS b
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec b
</span><a href="#local-6989586621679568594"><span class="hs-identifier hs-var">rp2</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec [b] -&gt; Int -&gt; ReadS [b]
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec [b]
</span><a href="#local-6989586621679568593"><span class="hs-identifier hs-var">rl2</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span></span><span>
</span><span id="line-342"></span><span>
</span><span id="line-343"></span><span class="hs-comment">-- | Lift the standard 'readsPrec' function through the type constructor.</span><span>
</span><span id="line-344"></span><span class="hs-comment">--</span><span>
</span><span id="line-345"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-346"></span><span id="local-6989586621679569075"><span id="local-6989586621679569076"><span id="local-6989586621679569077"><span class="annot"><a href="Data.Functor.Classes.html#readsPrec2"><span class="hs-identifier hs-type">readsPrec2</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Classes.html#Read2"><span class="hs-identifier hs-type">Read2</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569077"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569076"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569075"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679569077"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569076"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569075"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span></span></span></span><span>
</span><span id="line-347"></span><span id="readsPrec2"><span class="annot"><span class="annottext">readsPrec2 :: forall (f :: * -&gt; * -&gt; *) a b.
(Read2 f, Read a, Read b) =&gt;
Int -&gt; ReadS (f a b)
</span><a href="Data.Functor.Classes.html#readsPrec2"><span class="hs-identifier hs-var hs-var">readsPrec2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a)
-&gt; ReadS [a]
-&gt; (Int -&gt; ReadS b)
-&gt; ReadS [b]
-&gt; Int
-&gt; ReadS (f a b)
forall (f :: * -&gt; * -&gt; *) a b.
Read2 f =&gt;
(Int -&gt; ReadS a)
-&gt; ReadS [a]
-&gt; (Int -&gt; ReadS b)
-&gt; ReadS [b]
-&gt; Int
-&gt; ReadS (f a b)
</span><a href="Data.Functor.Classes.html#liftReadsPrec2"><span class="hs-identifier hs-var">liftReadsPrec2</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS a
forall a. Read a =&gt; Int -&gt; ReadS a
</span><a href="GHC.Read.html#readsPrec"><span class="hs-identifier hs-var">readsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">ReadS [a]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readList"><span class="hs-identifier hs-var">readList</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS b
forall a. Read a =&gt; Int -&gt; ReadS a
</span><a href="GHC.Read.html#readsPrec"><span class="hs-identifier hs-var">readsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">ReadS [b]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readList"><span class="hs-identifier hs-var">readList</span></a></span><span>
</span><span id="line-348"></span><span>
</span><span id="line-349"></span><span class="hs-comment">-- | Lift the standard 'readPrec' function through the type constructor.</span><span>
</span><span id="line-350"></span><span class="hs-comment">--</span><span>
</span><span id="line-351"></span><span class="hs-comment">-- @since 4.10.0.0</span><span>
</span><span id="line-352"></span><span id="local-6989586621679569069"><span id="local-6989586621679569070"><span id="local-6989586621679569071"><span class="annot"><a href="Data.Functor.Classes.html#readPrec2"><span class="hs-identifier hs-type">readPrec2</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Classes.html#Read2"><span class="hs-identifier hs-type">Read2</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569071"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569070"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569069"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679569071"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569070"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569069"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span></span></span></span><span>
</span><span id="line-353"></span><span id="readPrec2"><span class="annot"><span class="annottext">readPrec2 :: forall (f :: * -&gt; * -&gt; *) a b.
(Read2 f, Read a, Read b) =&gt;
ReadPrec (f a b)
</span><a href="Data.Functor.Classes.html#readPrec2"><span class="hs-identifier hs-var hs-var">readPrec2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec b -&gt; ReadPrec [b] -&gt; ReadPrec (f a b)
forall (f :: * -&gt; * -&gt; *) a b.
Read2 f =&gt;
ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec b -&gt; ReadPrec [b] -&gt; ReadPrec (f a b)
</span><a href="Data.Functor.Classes.html#liftReadPrec2"><span class="hs-identifier hs-var">liftReadPrec2</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrec"><span class="hs-identifier hs-var">readListPrec</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec b
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec [b]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrec"><span class="hs-identifier hs-var">readListPrec</span></a></span><span>
</span><span id="line-354"></span><span>
</span><span id="line-355"></span><span class="hs-comment">-- | A possible replacement definition for the 'liftReadList2' method.</span><span>
</span><span id="line-356"></span><span class="hs-comment">-- This is only needed for 'Read2' instances where 'liftReadListPrec2' isn't</span><span>
</span><span id="line-357"></span><span class="hs-comment">-- defined as 'liftReadListPrec2Default'.</span><span>
</span><span id="line-358"></span><span class="hs-comment">--</span><span>
</span><span id="line-359"></span><span class="hs-comment">-- @since 4.10.0.0</span><span>
</span><span id="line-360"></span><span id="local-6989586621679569063"><span id="local-6989586621679569064"><span id="local-6989586621679569065"><span class="annot"><a href="Data.Functor.Classes.html#liftReadList2Default"><span class="hs-identifier hs-type">liftReadList2Default</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Read2"><span class="hs-identifier hs-type">Read2</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569065"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569064"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569064"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-361"></span><span>    </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569063"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569063"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569065"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569064"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569063"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">]</span></span></span></span><span>
</span><span id="line-362"></span><span id="liftReadList2Default"><span class="annot"><span class="annottext">liftReadList2Default :: forall (f :: * -&gt; * -&gt; *) a b.
Read2 f =&gt;
(Int -&gt; ReadS a)
-&gt; ReadS [a] -&gt; (Int -&gt; ReadS b) -&gt; ReadS [b] -&gt; ReadS [f a b]
</span><a href="Data.Functor.Classes.html#liftReadList2Default"><span class="hs-identifier hs-var hs-var">liftReadList2Default</span></a></span></span><span> </span><span id="local-6989586621679568574"><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679568574"><span class="hs-identifier hs-var">rp1</span></a></span></span><span> </span><span id="local-6989586621679568573"><span class="annot"><span class="annottext">ReadS [a]
</span><a href="#local-6989586621679568573"><span class="hs-identifier hs-var">rl1</span></a></span></span><span> </span><span id="local-6989586621679568572"><span class="annot"><span class="annottext">Int -&gt; ReadS b
</span><a href="#local-6989586621679568572"><span class="hs-identifier hs-var">rp2</span></a></span></span><span> </span><span id="local-6989586621679568571"><span class="annot"><span class="annottext">ReadS [b]
</span><a href="#local-6989586621679568571"><span class="hs-identifier hs-var">rl2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [f a b] -&gt; Int -&gt; ReadS [f a b]
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span>
</span><span id="line-363"></span><span>    </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec b -&gt; ReadPrec [b] -&gt; ReadPrec [f a b]
forall (f :: * -&gt; * -&gt; *) a b.
Read2 f =&gt;
ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec b -&gt; ReadPrec [b] -&gt; ReadPrec [f a b]
</span><a href="Data.Functor.Classes.html#liftReadListPrec2"><span class="hs-identifier hs-var">liftReadListPrec2</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; ReadS a) -&gt; ReadPrec a
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679568574"><span class="hs-identifier hs-var">rp1</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; ReadS [a]) -&gt; ReadPrec [a]
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadS [a] -&gt; Int -&gt; ReadS [a]
forall a b. a -&gt; b -&gt; a
</span><a href="GHC.Base.html#const"><span class="hs-identifier hs-var">const</span></a></span><span> </span><span class="annot"><span class="annottext">ReadS [a]
</span><a href="#local-6989586621679568573"><span class="hs-identifier hs-var">rl1</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-364"></span><span>                       </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; ReadS b) -&gt; ReadPrec b
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS b
</span><a href="#local-6989586621679568572"><span class="hs-identifier hs-var">rp2</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; ReadS [b]) -&gt; ReadPrec [b]
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadS [b] -&gt; Int -&gt; ReadS [b]
forall a b. a -&gt; b -&gt; a
</span><a href="GHC.Base.html#const"><span class="hs-identifier hs-var">const</span></a></span><span> </span><span class="annot"><span class="annottext">ReadS [b]
</span><a href="#local-6989586621679568571"><span class="hs-identifier hs-var">rl2</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-365"></span><span>
</span><span id="line-366"></span><span class="hs-comment">-- | A possible replacement definition for the 'liftReadListPrec2' method,</span><span>
</span><span id="line-367"></span><span class="hs-comment">-- defined using 'liftReadPrec2'.</span><span>
</span><span id="line-368"></span><span class="hs-comment">--</span><span>
</span><span id="line-369"></span><span class="hs-comment">-- @since 4.10.0.0</span><span>
</span><span id="line-370"></span><span id="local-6989586621679569057"><span id="local-6989586621679569058"><span id="local-6989586621679569059"><span class="annot"><a href="Data.Functor.Classes.html#liftReadListPrec2Default"><span class="hs-identifier hs-type">liftReadListPrec2Default</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Read2"><span class="hs-identifier hs-type">Read2</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569059"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569058"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569058"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-371"></span><span>    </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569057"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569057"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569059"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569058"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569057"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">]</span></span></span></span><span>
</span><span id="line-372"></span><span id="liftReadListPrec2Default"><span class="annot"><span class="annottext">liftReadListPrec2Default :: forall (f :: * -&gt; * -&gt; *) a b.
Read2 f =&gt;
ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec b -&gt; ReadPrec [b] -&gt; ReadPrec [f a b]
</span><a href="Data.Functor.Classes.html#liftReadListPrec2Default"><span class="hs-identifier hs-var hs-var">liftReadListPrec2Default</span></a></span></span><span> </span><span id="local-6989586621679568568"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568568"><span class="hs-identifier hs-var">rp1</span></a></span></span><span> </span><span id="local-6989586621679568567"><span class="annot"><span class="annottext">ReadPrec [a]
</span><a href="#local-6989586621679568567"><span class="hs-identifier hs-var">rl1</span></a></span></span><span> </span><span id="local-6989586621679568566"><span class="annot"><span class="annottext">ReadPrec b
</span><a href="#local-6989586621679568566"><span class="hs-identifier hs-var">rp2</span></a></span></span><span> </span><span id="local-6989586621679568565"><span class="annot"><span class="annottext">ReadPrec [b]
</span><a href="#local-6989586621679568565"><span class="hs-identifier hs-var">rl2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (f a b) -&gt; ReadPrec [f a b]
forall a. ReadPrec a -&gt; ReadPrec [a]
</span><a href="GHC.Read.html#list"><span class="hs-identifier hs-var">list</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec b -&gt; ReadPrec [b] -&gt; ReadPrec (f a b)
forall (f :: * -&gt; * -&gt; *) a b.
Read2 f =&gt;
ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec b -&gt; ReadPrec [b] -&gt; ReadPrec (f a b)
</span><a href="Data.Functor.Classes.html#liftReadPrec2"><span class="hs-identifier hs-var">liftReadPrec2</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568568"><span class="hs-identifier hs-var">rp1</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
</span><a href="#local-6989586621679568567"><span class="hs-identifier hs-var">rl1</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec b
</span><a href="#local-6989586621679568566"><span class="hs-identifier hs-var">rp2</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec [b]
</span><a href="#local-6989586621679568565"><span class="hs-identifier hs-var">rl2</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-373"></span><span>
</span><span id="line-374"></span><span class="hs-comment">-- | Lifting of the 'Show' class to binary type constructors.</span><span>
</span><span id="line-375"></span><span class="hs-comment">--</span><span>
</span><span id="line-376"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-377"></span><span class="hs-keyword">class</span><span> </span><span id="Show2"><span class="annot"><a href="Data.Functor.Classes.html#Show2"><span class="hs-identifier hs-var">Show2</span></a></span></span><span> </span><span id="local-6989586621679569051"><span class="annot"><a href="#local-6989586621679569051"><span class="hs-identifier hs-type">f</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-378"></span><span>    </span><span class="hs-comment">-- | 'showsPrec' function for an application of the type constructor</span><span>
</span><span id="line-379"></span><span>    </span><span class="hs-comment">-- based on 'showsPrec' and 'showList' functions for the argument types.</span><span>
</span><span id="line-380"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-381"></span><span>    </span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-382"></span><span>    </span><span id="local-6989586621679569047"><span id="local-6989586621679569048"><span id="liftShowsPrec2"><span class="annot"><a href="Data.Functor.Classes.html#liftShowsPrec2"><span class="hs-identifier hs-type">liftShowsPrec2</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569048"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569048"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-383"></span><span>        </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569047"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569047"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569051"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569048"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569047"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span></span></span><span>
</span><span id="line-384"></span><span>
</span><span id="line-385"></span><span>    </span><span class="hs-comment">-- | 'showList' function for an application of the type constructor</span><span>
</span><span id="line-386"></span><span>    </span><span class="hs-comment">-- based on 'showsPrec' and 'showList' functions for the argument types.</span><span>
</span><span id="line-387"></span><span>    </span><span class="hs-comment">-- The default implementation using standard list syntax is correct</span><span>
</span><span id="line-388"></span><span>    </span><span class="hs-comment">-- for most types.</span><span>
</span><span id="line-389"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-390"></span><span>    </span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-391"></span><span>    </span><span id="local-6989586621679569052"><span id="local-6989586621679569053"><span id="liftShowList2"><span class="annot"><a href="Data.Functor.Classes.html#liftShowList2"><span class="hs-identifier hs-type">liftShowList2</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569053"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569053"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-392"></span><span>        </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569052"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569052"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679569051"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569053"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569052"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span></span></span><span>
</span><span id="line-393"></span><span>    </span><span id="local-6989586621679568561"><span class="annot"><a href="Data.Functor.Classes.html#liftShowList2"><span class="hs-identifier hs-var hs-var">liftShowList2</span></a></span><span> </span><span id="local-6989586621679568559"><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679568559"><span class="hs-identifier hs-var">sp1</span></a></span></span><span> </span><span id="local-6989586621679568558"><span class="annot"><span class="annottext">[a] -&gt; ShowS
</span><a href="#local-6989586621679568558"><span class="hs-identifier hs-var">sl1</span></a></span></span><span> </span><span id="local-6989586621679568557"><span class="annot"><span class="annottext">Int -&gt; b -&gt; ShowS
</span><a href="#local-6989586621679568557"><span class="hs-identifier hs-var">sp2</span></a></span></span><span> </span><span id="local-6989586621679568556"><span class="annot"><span class="annottext">[b] -&gt; ShowS
</span><a href="#local-6989586621679568556"><span class="hs-identifier hs-var">sl2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-394"></span><span>        </span><span class="annot"><span class="annottext">(f a b -&gt; ShowS) -&gt; [f a b] -&gt; ShowS
forall a. (a -&gt; ShowS) -&gt; [a] -&gt; ShowS
</span><a href="Text.Show.html#showListWith"><span class="hs-identifier hs-var">showListWith</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS)
-&gt; (Int -&gt; b -&gt; ShowS)
-&gt; ([b] -&gt; ShowS)
-&gt; Int
-&gt; f a b
-&gt; ShowS
forall (f :: * -&gt; * -&gt; *) a b.
Show2 f =&gt;
(Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS)
-&gt; (Int -&gt; b -&gt; ShowS)
-&gt; ([b] -&gt; ShowS)
-&gt; Int
-&gt; f a b
-&gt; ShowS
</span><a href="Data.Functor.Classes.html#liftShowsPrec2"><span class="hs-identifier hs-var">liftShowsPrec2</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679568559"><span class="hs-identifier hs-var">sp1</span></a></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
</span><a href="#local-6989586621679568558"><span class="hs-identifier hs-var">sl1</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; b -&gt; ShowS
</span><a href="#local-6989586621679568557"><span class="hs-identifier hs-var">sp2</span></a></span><span> </span><span class="annot"><span class="annottext">[b] -&gt; ShowS
</span><a href="#local-6989586621679568556"><span class="hs-identifier hs-var">sl2</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span></span><span>
</span><span id="line-395"></span><span>
</span><span id="line-396"></span><span class="hs-comment">-- | Lift the standard 'showsPrec' function through the type constructor.</span><span>
</span><span id="line-397"></span><span class="hs-comment">--</span><span>
</span><span id="line-398"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-399"></span><span id="local-6989586621679569044"><span id="local-6989586621679569045"><span id="local-6989586621679569046"><span class="annot"><a href="Data.Functor.Classes.html#showsPrec2"><span class="hs-identifier hs-type">showsPrec2</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Classes.html#Show2"><span class="hs-identifier hs-type">Show2</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569046"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Show.html#Show"><span class="hs-identifier hs-type">Show</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569045"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Show.html#Show"><span class="hs-identifier hs-type">Show</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569044"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569046"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569045"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569044"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span></span></span></span><span>
</span><span id="line-400"></span><span id="showsPrec2"><span class="annot"><span class="annottext">showsPrec2 :: forall (f :: * -&gt; * -&gt; *) a b.
(Show2 f, Show a, Show b) =&gt;
Int -&gt; f a b -&gt; ShowS
</span><a href="Data.Functor.Classes.html#showsPrec2"><span class="hs-identifier hs-var hs-var">showsPrec2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS)
-&gt; (Int -&gt; b -&gt; ShowS)
-&gt; ([b] -&gt; ShowS)
-&gt; Int
-&gt; f a b
-&gt; ShowS
forall (f :: * -&gt; * -&gt; *) a b.
Show2 f =&gt;
(Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS)
-&gt; (Int -&gt; b -&gt; ShowS)
-&gt; ([b] -&gt; ShowS)
-&gt; Int
-&gt; f a b
-&gt; ShowS
</span><a href="Data.Functor.Classes.html#liftShowsPrec2"><span class="hs-identifier hs-var">liftShowsPrec2</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
forall a. Show a =&gt; Int -&gt; a -&gt; ShowS
</span><a href="GHC.Show.html#showsPrec"><span class="hs-identifier hs-var">showsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
forall a. Show a =&gt; [a] -&gt; ShowS
</span><a href="GHC.Show.html#showList"><span class="hs-identifier hs-var">showList</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; b -&gt; ShowS
forall a. Show a =&gt; Int -&gt; a -&gt; ShowS
</span><a href="GHC.Show.html#showsPrec"><span class="hs-identifier hs-var">showsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">[b] -&gt; ShowS
forall a. Show a =&gt; [a] -&gt; ShowS
</span><a href="GHC.Show.html#showList"><span class="hs-identifier hs-var">showList</span></a></span><span>
</span><span id="line-401"></span><span>
</span><span id="line-402"></span><span class="hs-comment">-- Instances for Prelude type constructors</span><span>
</span><span id="line-403"></span><span>
</span><span id="line-404"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-405"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Eq1"><span class="hs-identifier hs-type">Eq1</span></a></span><span> </span><span class="annot"><a href="GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-406"></span><span>    </span><span id="local-6989586621679568544"><span class="annot"><span class="annottext">liftEq :: forall a b. (a -&gt; b -&gt; Bool) -&gt; Maybe a -&gt; Maybe b -&gt; Bool
</span><a href="#local-6989586621679568544"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftEq</span></a></span></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Maybe a
</span><a href="GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe b
</span><a href="GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../ghc-prim/src/GHC.Types.html#True"><span class="hs-identifier hs-var">True</span></a></span><span>
</span><span id="line-407"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftEq"><span class="hs-identifier hs-var">liftEq</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Maybe a
</span><a href="GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../ghc-prim/src/GHC.Types.html#False"><span class="hs-identifier hs-var">False</span></a></span><span>
</span><span id="line-408"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftEq"><span class="hs-identifier hs-var">liftEq</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Maybe b
</span><a href="GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../ghc-prim/src/GHC.Types.html#False"><span class="hs-identifier hs-var">False</span></a></span><span>
</span><span id="line-409"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftEq"><span class="hs-identifier hs-var">liftEq</span></a></span><span> </span><span id="local-6989586621679568543"><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679568543"><span class="hs-identifier hs-var">eq</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621679568542"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568542"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621679568541"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568541"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679568543"><span class="hs-identifier hs-var">eq</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568542"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568541"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-410"></span><span>
</span><span id="line-411"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-412"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Ord1"><span class="hs-identifier hs-type">Ord1</span></a></span><span> </span><span class="annot"><a href="GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-413"></span><span>    </span><span id="local-6989586621679568535"><span class="annot"><span class="annottext">liftCompare :: forall a b. (a -&gt; b -&gt; Ordering) -&gt; Maybe a -&gt; Maybe b -&gt; Ordering
</span><a href="#local-6989586621679568535"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftCompare</span></a></span></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Maybe a
</span><a href="GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe b
</span><a href="GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ordering
</span><a href="../../ghc-prim/src/GHC.Types.html#EQ"><span class="hs-identifier hs-var">EQ</span></a></span><span>
</span><span id="line-414"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftCompare"><span class="hs-identifier hs-var">liftCompare</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Maybe a
</span><a href="GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ordering
</span><a href="../../ghc-prim/src/GHC.Types.html#LT"><span class="hs-identifier hs-var">LT</span></a></span><span>
</span><span id="line-415"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftCompare"><span class="hs-identifier hs-var">liftCompare</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Maybe b
</span><a href="GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ordering
</span><a href="../../ghc-prim/src/GHC.Types.html#GT"><span class="hs-identifier hs-var">GT</span></a></span><span>
</span><span id="line-416"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftCompare"><span class="hs-identifier hs-var">liftCompare</span></a></span><span> </span><span id="local-6989586621679568534"><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679568534"><span class="hs-identifier hs-var">comp</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621679568533"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568533"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621679568532"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568532"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679568534"><span class="hs-identifier hs-var">comp</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568533"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568532"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-417"></span><span>
</span><span id="line-418"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-419"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568530"><span class="annot"><a href="Data.Functor.Classes.html#Read1"><span class="hs-identifier hs-type">Read1</span></a></span><span> </span><span class="annot"><a href="GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-420"></span><span>    </span><span id="local-6989586621679568520"><span class="annot"><span class="annottext">liftReadPrec :: forall a. ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec (Maybe a)
</span><a href="#local-6989586621679568520"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadPrec</span></a></span></span><span> </span><span id="local-6989586621679568519"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568519"><span class="hs-identifier hs-var">rp</span></a></span></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-421"></span><span>        </span><span class="annot"><span class="annottext">ReadPrec (Maybe a) -&gt; ReadPrec (Maybe a)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#parens"><span class="hs-identifier hs-var">parens</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var">expectP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Lexeme
</span><a href="Text.Read.Lex.html#Ident"><span class="hs-identifier hs-var">Ident</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Nothing&quot;</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ReadPrec () -&gt; ReadPrec (Maybe a) -&gt; ReadPrec (Maybe a)
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe a -&gt; ReadPrec (Maybe a)
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe a
forall a. Maybe a
</span><a href="GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-422"></span><span>        </span><span class="annot"><span class="annottext">ReadPrec (Maybe a) -&gt; ReadPrec (Maybe a) -&gt; ReadPrec (Maybe a)
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span>
</span><span id="line-423"></span><span>        </span><span class="annot"><span class="annottext">ReadPrec (Maybe a) -&gt; ReadPrec (Maybe a)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="Data.Functor.Classes.html#readData"><span class="hs-identifier hs-var">readData</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec a -&gt; String -&gt; (a -&gt; Maybe a) -&gt; ReadPrec (Maybe a)
forall a t. ReadPrec a -&gt; String -&gt; (a -&gt; t) -&gt; ReadPrec t
</span><a href="Data.Functor.Classes.html#readUnaryWith"><span class="hs-identifier hs-var">readUnaryWith</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568519"><span class="hs-identifier hs-var">rp</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Just&quot;</span></span><span> </span><span class="annot"><span class="annottext">a -&gt; Maybe a
forall a. a -&gt; Maybe a
</span><a href="GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-424"></span><span>
</span><span id="line-425"></span><span>    </span><span id="local-6989586621679568516"><span class="annot"><span class="annottext">liftReadListPrec :: forall a. ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [Maybe a]
</span><a href="#local-6989586621679568516"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [Maybe a]
forall (f :: * -&gt; *) a.
Read1 f =&gt;
ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [f a]
</span><a href="Data.Functor.Classes.html#liftReadListPrecDefault"><span class="hs-identifier hs-var">liftReadListPrecDefault</span></a></span><span>
</span><span id="line-426"></span><span>    </span><span id="local-6989586621679568514"><span class="annot"><span class="annottext">liftReadList :: forall a. (Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [Maybe a]
</span><a href="#local-6989586621679568514"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [Maybe a]
forall (f :: * -&gt; *) a.
Read1 f =&gt;
(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [f a]
</span><a href="Data.Functor.Classes.html#liftReadListDefault"><span class="hs-identifier hs-var">liftReadListDefault</span></a></span><span>
</span><span id="line-427"></span><span>
</span><span id="line-428"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-429"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568511"><span class="annot"><a href="Data.Functor.Classes.html#Show1"><span class="hs-identifier hs-type">Show1</span></a></span><span> </span><span class="annot"><a href="GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-430"></span><span>    </span><span id="local-6989586621679568509"><span class="annot"><span class="annottext">liftShowsPrec :: forall a.
(Int -&gt; a -&gt; ShowS) -&gt; ([a] -&gt; ShowS) -&gt; Int -&gt; Maybe a -&gt; ShowS
</span><a href="#local-6989586621679568509"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftShowsPrec</span></a></span></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Maybe a
</span><a href="GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; ShowS
</span><a href="GHC.Show.html#showString"><span class="hs-identifier hs-var">showString</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Nothing&quot;</span></span><span>
</span><span id="line-431"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftShowsPrec"><span class="hs-identifier hs-var">liftShowsPrec</span></a></span><span> </span><span id="local-6989586621679568507"><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679568507"><span class="hs-identifier hs-var">sp</span></a></span></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679568506"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679568506"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621679568505"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568505"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; a -&gt; ShowS) -&gt; String -&gt; Int -&gt; a -&gt; ShowS
forall a. (Int -&gt; a -&gt; ShowS) -&gt; String -&gt; Int -&gt; a -&gt; ShowS
</span><a href="Data.Functor.Classes.html#showsUnaryWith"><span class="hs-identifier hs-var">showsUnaryWith</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679568507"><span class="hs-identifier hs-var">sp</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Just&quot;</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679568506"><span class="hs-identifier hs-var">d</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568505"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-432"></span><span>
</span><span id="line-433"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-434"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Eq1"><span class="hs-identifier hs-type">Eq1</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-435"></span><span>    </span><span id="local-6989586621679568501"><span class="annot"><span class="annottext">liftEq :: forall a b. (a -&gt; b -&gt; Bool) -&gt; [a] -&gt; [b] -&gt; Bool
</span><a href="#local-6989586621679568501"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftEq</span></a></span></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../ghc-prim/src/GHC.Types.html#True"><span class="hs-identifier hs-var">True</span></a></span><span>
</span><span id="line-436"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftEq"><span class="hs-identifier hs-var">liftEq</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">b
</span><span class="hs-identifier">_</span></span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span class="annot"><span class="annottext">[b]
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../ghc-prim/src/GHC.Types.html#False"><span class="hs-identifier hs-var">False</span></a></span><span>
</span><span id="line-437"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftEq"><span class="hs-identifier hs-var">liftEq</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><span class="hs-identifier">_</span></span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span class="annot"><span class="annottext">[a]
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../ghc-prim/src/GHC.Types.html#False"><span class="hs-identifier hs-var">False</span></a></span><span>
</span><span id="line-438"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftEq"><span class="hs-identifier hs-var">liftEq</span></a></span><span> </span><span id="local-6989586621679568500"><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679568500"><span class="hs-identifier hs-var">eq</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679568499"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568499"><span class="hs-identifier hs-var">x</span></a></span></span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span id="local-6989586621679568498"><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679568498"><span class="hs-identifier hs-var">xs</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679568497"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568497"><span class="hs-identifier hs-var">y</span></a></span></span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span id="local-6989586621679568496"><span class="annot"><span class="annottext">[b]
</span><a href="#local-6989586621679568496"><span class="hs-identifier hs-var">ys</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679568500"><span class="hs-identifier hs-var">eq</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568499"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568497"><span class="hs-identifier hs-var">y</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%26%26"><span class="hs-operator hs-var">&amp;&amp;</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; b -&gt; Bool) -&gt; [a] -&gt; [b] -&gt; Bool
forall (f :: * -&gt; *) a b.
Eq1 f =&gt;
(a -&gt; b -&gt; Bool) -&gt; f a -&gt; f b -&gt; Bool
</span><a href="Data.Functor.Classes.html#liftEq"><span class="hs-identifier hs-var">liftEq</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679568500"><span class="hs-identifier hs-var">eq</span></a></span><span> </span><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679568498"><span class="hs-identifier hs-var">xs</span></a></span><span> </span><span class="annot"><span class="annottext">[b]
</span><a href="#local-6989586621679568496"><span class="hs-identifier hs-var">ys</span></a></span><span>
</span><span id="line-439"></span><span>
</span><span id="line-440"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-441"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Ord1"><span class="hs-identifier hs-type">Ord1</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-442"></span><span>    </span><span id="local-6989586621679568487"><span class="annot"><span class="annottext">liftCompare :: forall a b. (a -&gt; b -&gt; Ordering) -&gt; [a] -&gt; [b] -&gt; Ordering
</span><a href="#local-6989586621679568487"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftCompare</span></a></span></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ordering
</span><a href="../../ghc-prim/src/GHC.Types.html#EQ"><span class="hs-identifier hs-var">EQ</span></a></span><span>
</span><span id="line-443"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftCompare"><span class="hs-identifier hs-var">liftCompare</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">b
</span><span class="hs-identifier">_</span></span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span class="annot"><span class="annottext">[b]
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ordering
</span><a href="../../ghc-prim/src/GHC.Types.html#LT"><span class="hs-identifier hs-var">LT</span></a></span><span>
</span><span id="line-444"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftCompare"><span class="hs-identifier hs-var">liftCompare</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><span class="hs-identifier">_</span></span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span class="annot"><span class="annottext">[a]
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ordering
</span><a href="../../ghc-prim/src/GHC.Types.html#GT"><span class="hs-identifier hs-var">GT</span></a></span><span>
</span><span id="line-445"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftCompare"><span class="hs-identifier hs-var">liftCompare</span></a></span><span> </span><span id="local-6989586621679568486"><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679568486"><span class="hs-identifier hs-var">comp</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679568485"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568485"><span class="hs-identifier hs-var">x</span></a></span></span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span id="local-6989586621679568484"><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679568484"><span class="hs-identifier hs-var">xs</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679568483"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568483"><span class="hs-identifier hs-var">y</span></a></span></span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span id="local-6989586621679568482"><span class="annot"><span class="annottext">[b]
</span><a href="#local-6989586621679568482"><span class="hs-identifier hs-var">ys</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679568486"><span class="hs-identifier hs-var">comp</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568485"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568483"><span class="hs-identifier hs-var">y</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering -&gt; Ordering -&gt; Ordering
forall a. Monoid a =&gt; a -&gt; a -&gt; a
</span><a href="GHC.Base.html#mappend"><span class="hs-operator hs-var">`mappend`</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; b -&gt; Ordering) -&gt; [a] -&gt; [b] -&gt; Ordering
forall (f :: * -&gt; *) a b.
Ord1 f =&gt;
(a -&gt; b -&gt; Ordering) -&gt; f a -&gt; f b -&gt; Ordering
</span><a href="Data.Functor.Classes.html#liftCompare"><span class="hs-identifier hs-var">liftCompare</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679568486"><span class="hs-identifier hs-var">comp</span></a></span><span> </span><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679568484"><span class="hs-identifier hs-var">xs</span></a></span><span> </span><span class="annot"><span class="annottext">[b]
</span><a href="#local-6989586621679568482"><span class="hs-identifier hs-var">ys</span></a></span><span>
</span><span id="line-446"></span><span>
</span><span id="line-447"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-448"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568480"><span class="annot"><a href="Data.Functor.Classes.html#Read1"><span class="hs-identifier hs-type">Read1</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-449"></span><span>    </span><span id="local-6989586621679568476"><span class="annot"><span class="annottext">liftReadPrec :: forall a. ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [a]
</span><a href="#local-6989586621679568476"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadPrec</span></a></span></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679568475"><span class="annot"><span class="annottext">ReadPrec [a]
</span><a href="#local-6989586621679568475"><span class="hs-identifier hs-var">rl</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
</span><a href="#local-6989586621679568475"><span class="hs-identifier hs-var">rl</span></a></span><span>
</span><span id="line-450"></span><span>    </span><span id="local-6989586621679568473"><span class="annot"><span class="annottext">liftReadListPrec :: forall a. ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [[a]]
</span><a href="#local-6989586621679568473"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadListPrec</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [[a]]
forall (f :: * -&gt; *) a.
Read1 f =&gt;
ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [f a]
</span><a href="Data.Functor.Classes.html#liftReadListPrecDefault"><span class="hs-identifier hs-var">liftReadListPrecDefault</span></a></span><span>
</span><span id="line-451"></span><span>    </span><span id="local-6989586621679568471"><span class="annot"><span class="annottext">liftReadList :: forall a. (Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [[a]]
</span><a href="#local-6989586621679568471"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadList</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [[a]]
forall (f :: * -&gt; *) a.
Read1 f =&gt;
(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [f a]
</span><a href="Data.Functor.Classes.html#liftReadListDefault"><span class="hs-identifier hs-var">liftReadListDefault</span></a></span><span>
</span><span id="line-452"></span><span>
</span><span id="line-453"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-454"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568468"><span class="annot"><a href="Data.Functor.Classes.html#Show1"><span class="hs-identifier hs-type">Show1</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-455"></span><span>    </span><span id="local-6989586621679568467"><span class="annot"><span class="annottext">liftShowsPrec :: forall a.
(Int -&gt; a -&gt; ShowS) -&gt; ([a] -&gt; ShowS) -&gt; Int -&gt; [a] -&gt; ShowS
</span><a href="#local-6989586621679568467"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftShowsPrec</span></a></span></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679568466"><span class="annot"><span class="annottext">[a] -&gt; ShowS
</span><a href="#local-6989586621679568466"><span class="hs-identifier hs-var">sl</span></a></span></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
</span><a href="#local-6989586621679568466"><span class="hs-identifier hs-var">sl</span></a></span><span>
</span><span id="line-456"></span><span>
</span><span id="line-457"></span><span class="hs-comment">-- | @since 4.10.0.0</span><span>
</span><span id="line-458"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Eq1"><span class="hs-identifier hs-type">Eq1</span></a></span><span> </span><span class="annot"><a href="GHC.Base.html#NonEmpty"><span class="hs-identifier hs-type">NonEmpty</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-459"></span><span>  </span><span id="local-6989586621679568462"><span class="annot"><span class="annottext">liftEq :: forall a b. (a -&gt; b -&gt; Bool) -&gt; NonEmpty a -&gt; NonEmpty b -&gt; Bool
</span><a href="#local-6989586621679568462"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftEq</span></a></span></span><span> </span><span id="local-6989586621679568461"><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679568461"><span class="hs-identifier hs-var">eq</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679568460"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568460"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="annot"><a href="GHC.Base.html#%3A%7C"><span class="hs-operator hs-type">:|</span></a></span><span> </span><span id="local-6989586621679568458"><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679568458"><span class="hs-keyword hs-var">as</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679568457"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568457"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="annot"><a href="GHC.Base.html#%3A%7C"><span class="hs-operator hs-type">:|</span></a></span><span> </span><span id="local-6989586621679568456"><span class="annot"><span class="annottext">[b]
</span><a href="#local-6989586621679568456"><span class="hs-identifier hs-var">bs</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679568461"><span class="hs-identifier hs-var">eq</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568460"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568457"><span class="hs-identifier hs-var">b</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%26%26"><span class="hs-operator hs-var">&amp;&amp;</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; b -&gt; Bool) -&gt; [a] -&gt; [b] -&gt; Bool
forall (f :: * -&gt; *) a b.
Eq1 f =&gt;
(a -&gt; b -&gt; Bool) -&gt; f a -&gt; f b -&gt; Bool
</span><a href="Data.Functor.Classes.html#liftEq"><span class="hs-identifier hs-var">liftEq</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679568461"><span class="hs-identifier hs-var">eq</span></a></span><span> </span><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679568458"><span class="hs-keyword hs-var">as</span></a></span><span> </span><span class="annot"><span class="annottext">[b]
</span><a href="#local-6989586621679568456"><span class="hs-identifier hs-var">bs</span></a></span><span>
</span><span id="line-460"></span><span>
</span><span id="line-461"></span><span class="hs-comment">-- | @since 4.10.0.0</span><span>
</span><span id="line-462"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Ord1"><span class="hs-identifier hs-type">Ord1</span></a></span><span> </span><span class="annot"><a href="GHC.Base.html#NonEmpty"><span class="hs-identifier hs-type">NonEmpty</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-463"></span><span>  </span><span id="local-6989586621679568449"><span class="annot"><span class="annottext">liftCompare :: forall a b.
(a -&gt; b -&gt; Ordering) -&gt; NonEmpty a -&gt; NonEmpty b -&gt; Ordering
</span><a href="#local-6989586621679568449"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftCompare</span></a></span></span><span> </span><span id="local-6989586621679568448"><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679568448"><span class="hs-identifier hs-var">cmp</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679568447"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568447"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="annot"><a href="GHC.Base.html#%3A%7C"><span class="hs-operator hs-type">:|</span></a></span><span> </span><span id="local-6989586621679568446"><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679568446"><span class="hs-keyword hs-var">as</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679568445"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568445"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="annot"><a href="GHC.Base.html#%3A%7C"><span class="hs-operator hs-type">:|</span></a></span><span> </span><span id="local-6989586621679568444"><span class="annot"><span class="annottext">[b]
</span><a href="#local-6989586621679568444"><span class="hs-identifier hs-var">bs</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679568448"><span class="hs-identifier hs-var">cmp</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568447"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568445"><span class="hs-identifier hs-var">b</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering -&gt; Ordering -&gt; Ordering
forall a. Monoid a =&gt; a -&gt; a -&gt; a
</span><a href="GHC.Base.html#mappend"><span class="hs-operator hs-var">`mappend`</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; b -&gt; Ordering) -&gt; [a] -&gt; [b] -&gt; Ordering
forall (f :: * -&gt; *) a b.
Ord1 f =&gt;
(a -&gt; b -&gt; Ordering) -&gt; f a -&gt; f b -&gt; Ordering
</span><a href="Data.Functor.Classes.html#liftCompare"><span class="hs-identifier hs-var">liftCompare</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679568448"><span class="hs-identifier hs-var">cmp</span></a></span><span> </span><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679568446"><span class="hs-keyword hs-var">as</span></a></span><span> </span><span class="annot"><span class="annottext">[b]
</span><a href="#local-6989586621679568444"><span class="hs-identifier hs-var">bs</span></a></span><span>
</span><span id="line-464"></span><span>
</span><span id="line-465"></span><span class="hs-comment">-- | @since 4.10.0.0</span><span>
</span><span id="line-466"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568437"><span id="local-6989586621679568439"><span id="local-6989586621679568441"><span class="annot"><a href="Data.Functor.Classes.html#Read1"><span class="hs-identifier hs-type">Read1</span></a></span><span> </span><span class="annot"><a href="GHC.Base.html#NonEmpty"><span class="hs-identifier hs-type">NonEmpty</span></a></span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-467"></span><span>  </span><span id="local-6989586621679568425"><span class="annot"><span class="annottext">liftReadsPrec :: forall a.
(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; Int -&gt; ReadS (NonEmpty a)
</span><a href="#local-6989586621679568425"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadsPrec</span></a></span></span><span> </span><span id="local-6989586621679568424"><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679568424"><span class="hs-identifier hs-var">rdP</span></a></span></span><span> </span><span id="local-6989586621679568423"><span class="annot"><span class="annottext">ReadS [a]
</span><a href="#local-6989586621679568423"><span class="hs-identifier hs-var">rdL</span></a></span></span><span> </span><span id="local-6989586621679568422"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679568422"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679568421"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568421"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; ReadS (NonEmpty a) -&gt; ReadS (NonEmpty a)
forall a. Bool -&gt; ReadS a -&gt; ReadS a
</span><a href="GHC.Read.html#readParen"><span class="hs-identifier hs-var">readParen</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679568422"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E"><span class="hs-operator hs-var">&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">5</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621679568418"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568418"><span class="hs-identifier hs-var">s'</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-468"></span><span>    </span><span class="hs-special">(</span><span id="local-6989586621679568417"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568417"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679568416"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568416"><span class="hs-identifier hs-var">s''</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679568424"><span class="hs-identifier hs-var">rdP</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">6</span></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568418"><span class="hs-identifier hs-var">s'</span></a></span><span>
</span><span id="line-469"></span><span>    </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;:|&quot;</span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679568415"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568415"><span class="hs-identifier hs-var">s'''</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadS String
</span><a href="GHC.Read.html#lex"><span class="hs-identifier hs-var">lex</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568416"><span class="hs-identifier hs-var">s''</span></a></span><span>
</span><span id="line-470"></span><span>    </span><span class="hs-special">(</span><span id="local-6989586621679568413"><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679568413"><span class="hs-keyword hs-var">as</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679568412"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568412"><span class="hs-identifier hs-var">s''''</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadS [a]
</span><a href="#local-6989586621679568423"><span class="hs-identifier hs-var">rdL</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568415"><span class="hs-identifier hs-var">s'''</span></a></span><span>
</span><span id="line-471"></span><span>    </span><span class="annot"><span class="annottext">(NonEmpty a, String) -&gt; [(NonEmpty a, String)]
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568417"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; [a] -&gt; NonEmpty a
forall a. a -&gt; [a] -&gt; NonEmpty a
</span><a href="GHC.Base.html#%3A%7C"><span class="hs-operator hs-var">:|</span></a></span><span> </span><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679568413"><span class="hs-keyword hs-var">as</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568412"><span class="hs-identifier hs-var">s''''</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568421"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-472"></span><span>
</span><span id="line-473"></span><span class="hs-comment">-- | @since 4.10.0.0</span><span>
</span><span id="line-474"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568409"><span class="annot"><a href="Data.Functor.Classes.html#Show1"><span class="hs-identifier hs-type">Show1</span></a></span><span> </span><span class="annot"><a href="GHC.Base.html#NonEmpty"><span class="hs-identifier hs-type">NonEmpty</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-475"></span><span>  </span><span id="local-6989586621679568406"><span class="annot"><span class="annottext">liftShowsPrec :: forall a.
(Int -&gt; a -&gt; ShowS) -&gt; ([a] -&gt; ShowS) -&gt; Int -&gt; NonEmpty a -&gt; ShowS
</span><a href="#local-6989586621679568406"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftShowsPrec</span></a></span></span><span> </span><span id="local-6989586621679568405"><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679568405"><span class="hs-identifier hs-var">shwP</span></a></span></span><span> </span><span id="local-6989586621679568404"><span class="annot"><span class="annottext">[a] -&gt; ShowS
</span><a href="#local-6989586621679568404"><span class="hs-identifier hs-var">shwL</span></a></span></span><span> </span><span id="local-6989586621679568403"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679568403"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679568402"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568402"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="annot"><a href="GHC.Base.html#%3A%7C"><span class="hs-operator hs-type">:|</span></a></span><span> </span><span id="local-6989586621679568401"><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679568401"><span class="hs-keyword hs-var">as</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; ShowS -&gt; ShowS
</span><a href="GHC.Show.html#showParen"><span class="hs-identifier hs-var">showParen</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679568403"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E"><span class="hs-operator hs-var">&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">5</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(ShowS -&gt; ShowS) -&gt; ShowS -&gt; ShowS
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-476"></span><span>    </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679568405"><span class="hs-identifier hs-var">shwP</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">6</span></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568402"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; ShowS -&gt; ShowS
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; ShowS
</span><a href="GHC.Show.html#showString"><span class="hs-identifier hs-var">showString</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot; :| &quot;</span></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; ShowS -&gt; ShowS
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
</span><a href="#local-6989586621679568404"><span class="hs-identifier hs-var">shwL</span></a></span><span> </span><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679568401"><span class="hs-keyword hs-var">as</span></a></span><span>
</span><span id="line-477"></span><span>
</span><span id="line-478"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-479"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Eq2"><span class="hs-identifier hs-type">Eq2</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">,</span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-480"></span><span>    </span><span id="local-6989586621679568395"><span class="annot"><span class="annottext">liftEq2 :: forall a b c d.
(a -&gt; b -&gt; Bool) -&gt; (c -&gt; d -&gt; Bool) -&gt; (a, c) -&gt; (b, d) -&gt; Bool
</span><a href="#local-6989586621679568395"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftEq2</span></a></span></span><span> </span><span id="local-6989586621679568394"><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679568394"><span class="hs-identifier hs-var">e1</span></a></span></span><span> </span><span id="local-6989586621679568393"><span class="annot"><span class="annottext">c -&gt; d -&gt; Bool
</span><a href="#local-6989586621679568393"><span class="hs-identifier hs-var">e2</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679568392"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568392"><span class="hs-identifier hs-var">x1</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679568391"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679568391"><span class="hs-identifier hs-var">y1</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679568390"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568390"><span class="hs-identifier hs-var">x2</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679568389"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679568389"><span class="hs-identifier hs-var">y2</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679568394"><span class="hs-identifier hs-var">e1</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568392"><span class="hs-identifier hs-var">x1</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568390"><span class="hs-identifier hs-var">x2</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%26%26"><span class="hs-operator hs-var">&amp;&amp;</span></a></span><span> </span><span class="annot"><span class="annottext">c -&gt; d -&gt; Bool
</span><a href="#local-6989586621679568393"><span class="hs-identifier hs-var">e2</span></a></span><span> </span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679568391"><span class="hs-identifier hs-var">y1</span></a></span><span> </span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679568389"><span class="hs-identifier hs-var">y2</span></a></span><span>
</span><span id="line-481"></span><span>
</span><span id="line-482"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-483"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Ord2"><span class="hs-identifier hs-type">Ord2</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">,</span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-484"></span><span>    </span><span id="local-6989586621679568382"><span class="annot"><span class="annottext">liftCompare2 :: forall a b c d.
(a -&gt; b -&gt; Ordering)
-&gt; (c -&gt; d -&gt; Ordering) -&gt; (a, c) -&gt; (b, d) -&gt; Ordering
</span><a href="#local-6989586621679568382"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftCompare2</span></a></span></span><span> </span><span id="local-6989586621679568381"><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679568381"><span class="hs-identifier hs-var">comp1</span></a></span></span><span> </span><span id="local-6989586621679568380"><span class="annot"><span class="annottext">c -&gt; d -&gt; Ordering
</span><a href="#local-6989586621679568380"><span class="hs-identifier hs-var">comp2</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679568379"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568379"><span class="hs-identifier hs-var">x1</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679568378"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679568378"><span class="hs-identifier hs-var">y1</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679568377"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568377"><span class="hs-identifier hs-var">x2</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679568376"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679568376"><span class="hs-identifier hs-var">y2</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-485"></span><span>        </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679568381"><span class="hs-identifier hs-var">comp1</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568379"><span class="hs-identifier hs-var">x1</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568377"><span class="hs-identifier hs-var">x2</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering -&gt; Ordering -&gt; Ordering
forall a. Monoid a =&gt; a -&gt; a -&gt; a
</span><a href="GHC.Base.html#mappend"><span class="hs-operator hs-var">`mappend`</span></a></span><span> </span><span class="annot"><span class="annottext">c -&gt; d -&gt; Ordering
</span><a href="#local-6989586621679568380"><span class="hs-identifier hs-var">comp2</span></a></span><span> </span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679568378"><span class="hs-identifier hs-var">y1</span></a></span><span> </span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679568376"><span class="hs-identifier hs-var">y2</span></a></span><span>
</span><span id="line-486"></span><span>
</span><span id="line-487"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-488"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568374"><span class="annot"><a href="Data.Functor.Classes.html#Read2"><span class="hs-identifier hs-type">Read2</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">,</span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-489"></span><span>    </span><span id="local-6989586621679568364"><span class="annot"><span class="annottext">liftReadPrec2 :: forall a b.
ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec b -&gt; ReadPrec [b] -&gt; ReadPrec (a, b)
</span><a href="#local-6989586621679568364"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadPrec2</span></a></span></span><span> </span><span id="local-6989586621679568363"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568363"><span class="hs-identifier hs-var">rp1</span></a></span></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679568362"><span class="annot"><span class="annottext">ReadPrec b
</span><a href="#local-6989586621679568362"><span class="hs-identifier hs-var">rp2</span></a></span></span><span> </span><span class="annot"><span class="annottext">ReadPrec [b]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b) -&gt; ReadPrec (a, b)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#parens"><span class="hs-identifier hs-var">parens</span></a></span><span> </span><span class="annot"><span class="annottext">(ReadPrec (a, b) -&gt; ReadPrec (a, b))
-&gt; ReadPrec (a, b) -&gt; ReadPrec (a, b)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b) -&gt; ReadPrec (a, b)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#paren"><span class="hs-identifier hs-var">paren</span></a></span><span> </span><span class="annot"><span class="annottext">(ReadPrec (a, b) -&gt; ReadPrec (a, b))
-&gt; ReadPrec (a, b) -&gt; ReadPrec (a, b)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-490"></span><span>        </span><span id="local-6989586621679568361"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568361"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568363"><span class="hs-identifier hs-var">rp1</span></a></span><span>
</span><span id="line-491"></span><span>        </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var">expectP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Lexeme
</span><a href="Text.Read.Lex.html#Punc"><span class="hs-identifier hs-var">Punc</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;,&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-492"></span><span>        </span><span id="local-6989586621679568359"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568359"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec b
</span><a href="#local-6989586621679568362"><span class="hs-identifier hs-var">rp2</span></a></span><span>
</span><span id="line-493"></span><span>        </span><span class="annot"><span class="annottext">(a, b) -&gt; ReadPrec (a, b)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568361"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568359"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-494"></span><span>
</span><span id="line-495"></span><span>    </span><span id="local-6989586621679568357"><span class="annot"><span class="annottext">liftReadListPrec2 :: forall a b.
ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec b -&gt; ReadPrec [b] -&gt; ReadPrec [(a, b)]
</span><a href="#local-6989586621679568357"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadListPrec2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec b -&gt; ReadPrec [b] -&gt; ReadPrec [(a, b)]
forall (f :: * -&gt; * -&gt; *) a b.
Read2 f =&gt;
ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec b -&gt; ReadPrec [b] -&gt; ReadPrec [f a b]
</span><a href="Data.Functor.Classes.html#liftReadListPrec2Default"><span class="hs-identifier hs-var">liftReadListPrec2Default</span></a></span><span>
</span><span id="line-496"></span><span>    </span><span id="local-6989586621679568355"><span class="annot"><span class="annottext">liftReadList2 :: forall a b.
(Int -&gt; ReadS a)
-&gt; ReadS [a] -&gt; (Int -&gt; ReadS b) -&gt; ReadS [b] -&gt; ReadS [(a, b)]
</span><a href="#local-6989586621679568355"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadList2</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a)
-&gt; ReadS [a] -&gt; (Int -&gt; ReadS b) -&gt; ReadS [b] -&gt; ReadS [(a, b)]
forall (f :: * -&gt; * -&gt; *) a b.
Read2 f =&gt;
(Int -&gt; ReadS a)
-&gt; ReadS [a] -&gt; (Int -&gt; ReadS b) -&gt; ReadS [b] -&gt; ReadS [f a b]
</span><a href="Data.Functor.Classes.html#liftReadList2Default"><span class="hs-identifier hs-var">liftReadList2Default</span></a></span><span>
</span><span id="line-497"></span><span>
</span><span id="line-498"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-499"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568352"><span class="annot"><a href="Data.Functor.Classes.html#Show2"><span class="hs-identifier hs-type">Show2</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">,</span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-500"></span><span>    </span><span id="local-6989586621679568350"><span class="annot"><span class="annottext">liftShowsPrec2 :: forall a b.
(Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS)
-&gt; (Int -&gt; b -&gt; ShowS)
-&gt; ([b] -&gt; ShowS)
-&gt; Int
-&gt; (a, b)
-&gt; ShowS
</span><a href="#local-6989586621679568350"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftShowsPrec2</span></a></span></span><span> </span><span id="local-6989586621679568349"><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679568349"><span class="hs-identifier hs-var">sp1</span></a></span></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679568348"><span class="annot"><span class="annottext">Int -&gt; b -&gt; ShowS
</span><a href="#local-6989586621679568348"><span class="hs-identifier hs-var">sp2</span></a></span></span><span> </span><span class="annot"><span class="annottext">[b] -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679568347"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568347"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679568346"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568346"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-501"></span><span>        </span><span class="annot"><span class="annottext">Char -&gt; ShowS
</span><a href="GHC.Show.html#showChar"><span class="hs-identifier hs-var">showChar</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'('</span></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; ShowS -&gt; ShowS
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679568349"><span class="hs-identifier hs-var">sp1</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568347"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; ShowS -&gt; ShowS
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; ShowS
</span><a href="GHC.Show.html#showChar"><span class="hs-identifier hs-var">showChar</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">','</span></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; ShowS -&gt; ShowS
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; b -&gt; ShowS
</span><a href="#local-6989586621679568348"><span class="hs-identifier hs-var">sp2</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568346"><span class="hs-identifier hs-var">y</span></a></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; ShowS -&gt; ShowS
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; ShowS
</span><a href="GHC.Show.html#showChar"><span class="hs-identifier hs-var">showChar</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">')'</span></span><span>
</span><span id="line-502"></span><span>
</span><span id="line-503"></span><span class="hs-comment">-- | @since 4.15</span><span>
</span><span id="line-504"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Eq1"><span class="hs-identifier hs-type">Eq1</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Tuple.html#Solo"><span class="hs-identifier hs-type">Solo</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-505"></span><span>  </span><span id="local-6989586621679568342"><span class="annot"><span class="annottext">liftEq :: forall a b. (a -&gt; b -&gt; Bool) -&gt; Solo a -&gt; Solo b -&gt; Bool
</span><a href="#local-6989586621679568342"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftEq</span></a></span></span><span> </span><span id="local-6989586621679568341"><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679568341"><span class="hs-identifier hs-var">eq</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Tuple.html#Solo"><span class="hs-identifier hs-type">Solo</span></a></span><span> </span><span id="local-6989586621679568340"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568340"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Tuple.html#Solo"><span class="hs-identifier hs-type">Solo</span></a></span><span> </span><span id="local-6989586621679568339"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568339"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568340"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679568341"><span class="hs-operator hs-var">`eq`</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568339"><span class="hs-identifier hs-var">b</span></a></span><span>
</span><span id="line-506"></span><span>
</span><span id="line-507"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-508"></span><span id="local-6989586621679568978"><span class="hs-keyword">instance</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Classes.html#Eq"><span class="hs-identifier hs-type">Eq</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568978"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Eq1"><span class="hs-identifier hs-type">Eq1</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="hs-special">,</span><span class="hs-special">)</span><span> </span><span class="annot"><a href="#local-6989586621679568978"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-509"></span><span>    </span><span id="local-6989586621679568333"><span class="annot"><span class="annottext">liftEq :: forall a b. (a -&gt; b -&gt; Bool) -&gt; (a, a) -&gt; (a, b) -&gt; Bool
</span><a href="#local-6989586621679568333"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftEq</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; a -&gt; Bool) -&gt; (a -&gt; b -&gt; Bool) -&gt; (a, a) -&gt; (a, b) -&gt; Bool
forall (f :: * -&gt; * -&gt; *) a b c d.
Eq2 f =&gt;
(a -&gt; b -&gt; Bool) -&gt; (c -&gt; d -&gt; Bool) -&gt; f a c -&gt; f b d -&gt; Bool
</span><a href="Data.Functor.Classes.html#liftEq2"><span class="hs-identifier hs-var">liftEq2</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">(==)</span></a></span></span><span>
</span><span id="line-510"></span><span>
</span><span id="line-511"></span><span class="hs-comment">-- | @since 4.15</span><span>
</span><span id="line-512"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Ord1"><span class="hs-identifier hs-type">Ord1</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Tuple.html#Solo"><span class="hs-identifier hs-type">Solo</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-513"></span><span>  </span><span id="local-6989586621679568328"><span class="annot"><span class="annottext">liftCompare :: forall a b. (a -&gt; b -&gt; Ordering) -&gt; Solo a -&gt; Solo b -&gt; Ordering
</span><a href="#local-6989586621679568328"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftCompare</span></a></span></span><span> </span><span id="local-6989586621679568327"><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679568327"><span class="hs-identifier hs-var">cmp</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Tuple.html#Solo"><span class="hs-identifier hs-type">Solo</span></a></span><span> </span><span id="local-6989586621679568326"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568326"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Tuple.html#Solo"><span class="hs-identifier hs-type">Solo</span></a></span><span> </span><span id="local-6989586621679568325"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568325"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679568327"><span class="hs-identifier hs-var">cmp</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568326"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568325"><span class="hs-identifier hs-var">b</span></a></span><span>
</span><span id="line-514"></span><span>
</span><span id="line-515"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-516"></span><span id="local-6989586621679568972"><span class="hs-keyword">instance</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Classes.html#Ord"><span class="hs-identifier hs-type">Ord</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568972"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Ord1"><span class="hs-identifier hs-type">Ord1</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="hs-special">,</span><span class="hs-special">)</span><span> </span><span class="annot"><a href="#local-6989586621679568972"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-517"></span><span>    </span><span id="local-6989586621679568315"><span class="annot"><span class="annottext">liftCompare :: forall a b. (a -&gt; b -&gt; Ordering) -&gt; (a, a) -&gt; (a, b) -&gt; Ordering
</span><a href="#local-6989586621679568315"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftCompare</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; a -&gt; Ordering)
-&gt; (a -&gt; b -&gt; Ordering) -&gt; (a, a) -&gt; (a, b) -&gt; Ordering
forall (f :: * -&gt; * -&gt; *) a b c d.
Ord2 f =&gt;
(a -&gt; b -&gt; Ordering)
-&gt; (c -&gt; d -&gt; Ordering) -&gt; f a c -&gt; f b d -&gt; Ordering
</span><a href="Data.Functor.Classes.html#liftCompare2"><span class="hs-identifier hs-var">liftCompare2</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Ordering
forall a. Ord a =&gt; a -&gt; a -&gt; Ordering
</span><a href="../../ghc-prim/src/GHC.Classes.html#compare"><span class="hs-identifier hs-var">compare</span></a></span></span><span>
</span><span id="line-518"></span><span>
</span><span id="line-519"></span><span class="hs-comment">-- | @since 4.15</span><span>
</span><span id="line-520"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568313"><span class="annot"><a href="Data.Functor.Classes.html#Read1"><span class="hs-identifier hs-type">Read1</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Tuple.html#Solo"><span class="hs-identifier hs-type">Solo</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-521"></span><span>    </span><span id="local-6989586621679568309"><span class="annot"><span class="annottext">liftReadPrec :: forall a. ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec (Solo a)
</span><a href="#local-6989586621679568309"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadPrec</span></a></span></span><span> </span><span id="local-6989586621679568308"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568308"><span class="hs-identifier hs-var">rp</span></a></span></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (Solo a) -&gt; ReadPrec (Solo a)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="Data.Functor.Classes.html#readData"><span class="hs-identifier hs-var">readData</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec a -&gt; String -&gt; (a -&gt; Solo a) -&gt; ReadPrec (Solo a)
forall a t. ReadPrec a -&gt; String -&gt; (a -&gt; t) -&gt; ReadPrec t
</span><a href="Data.Functor.Classes.html#readUnaryWith"><span class="hs-identifier hs-var">readUnaryWith</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568308"><span class="hs-identifier hs-var">rp</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Solo&quot;</span></span><span> </span><span class="annot"><span class="annottext">a -&gt; Solo a
forall a. a -&gt; Solo a
</span><a href="../../ghc-prim/src/GHC.Tuple.html#Solo"><span class="hs-identifier hs-var">Solo</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-522"></span><span>
</span><span id="line-523"></span><span>    </span><span id="local-6989586621679568306"><span class="annot"><span class="annottext">liftReadListPrec :: forall a. ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [Solo a]
</span><a href="#local-6989586621679568306"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [Solo a]
forall (f :: * -&gt; *) a.
Read1 f =&gt;
ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [f a]
</span><a href="Data.Functor.Classes.html#liftReadListPrecDefault"><span class="hs-identifier hs-var">liftReadListPrecDefault</span></a></span><span>
</span><span id="line-524"></span><span>    </span><span id="local-6989586621679568304"><span class="annot"><span class="annottext">liftReadList :: forall a. (Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [Solo a]
</span><a href="#local-6989586621679568304"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [Solo a]
forall (f :: * -&gt; *) a.
Read1 f =&gt;
(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [f a]
</span><a href="Data.Functor.Classes.html#liftReadListDefault"><span class="hs-identifier hs-var">liftReadListDefault</span></a></span><span>
</span><span id="line-525"></span><span>
</span><span id="line-526"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-527"></span><span id="local-6989586621679568966"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568302"><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568966"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Read1"><span class="hs-identifier hs-type">Read1</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="hs-special">,</span><span class="hs-special">)</span><span> </span><span class="annot"><a href="#local-6989586621679568966"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-528"></span><span>    </span><span id="local-6989586621679568295"><span class="annot"><span class="annottext">liftReadPrec :: forall a. ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec (a, a)
</span><a href="#local-6989586621679568295"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec (a, a)
forall (f :: * -&gt; * -&gt; *) a b.
Read2 f =&gt;
ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec b -&gt; ReadPrec [b] -&gt; ReadPrec (f a b)
</span><a href="Data.Functor.Classes.html#liftReadPrec2"><span class="hs-identifier hs-var">liftReadPrec2</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrec"><span class="hs-identifier hs-var">readListPrec</span></a></span><span>
</span><span id="line-529"></span><span>
</span><span id="line-530"></span><span>    </span><span id="local-6989586621679568293"><span class="annot"><span class="annottext">liftReadListPrec :: forall a. ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [(a, a)]
</span><a href="#local-6989586621679568293"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [(a, a)]
forall (f :: * -&gt; *) a.
Read1 f =&gt;
ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [f a]
</span><a href="Data.Functor.Classes.html#liftReadListPrecDefault"><span class="hs-identifier hs-var">liftReadListPrecDefault</span></a></span><span>
</span><span id="line-531"></span><span>    </span><span id="local-6989586621679568291"><span class="annot"><span class="annottext">liftReadList :: forall a. (Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [(a, a)]
</span><a href="#local-6989586621679568291"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [(a, a)]
forall (f :: * -&gt; *) a.
Read1 f =&gt;
(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [f a]
</span><a href="Data.Functor.Classes.html#liftReadListDefault"><span class="hs-identifier hs-var">liftReadListDefault</span></a></span></span><span>
</span><span id="line-532"></span><span>
</span><span id="line-533"></span><span class="hs-comment">-- | @since 4.15</span><span>
</span><span id="line-534"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568288"><span class="annot"><a href="Data.Functor.Classes.html#Show1"><span class="hs-identifier hs-type">Show1</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Tuple.html#Solo"><span class="hs-identifier hs-type">Solo</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-535"></span><span>    </span><span id="local-6989586621679568287"><span class="annot"><span class="annottext">liftShowsPrec :: forall a.
(Int -&gt; a -&gt; ShowS) -&gt; ([a] -&gt; ShowS) -&gt; Int -&gt; Solo a -&gt; ShowS
</span><a href="#local-6989586621679568287"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftShowsPrec</span></a></span></span><span> </span><span id="local-6989586621679568286"><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679568286"><span class="hs-identifier hs-var">sp</span></a></span></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679568285"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679568285"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Tuple.html#Solo"><span class="hs-identifier hs-type">Solo</span></a></span><span> </span><span id="local-6989586621679568284"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568284"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; a -&gt; ShowS) -&gt; String -&gt; Int -&gt; a -&gt; ShowS
forall a. (Int -&gt; a -&gt; ShowS) -&gt; String -&gt; Int -&gt; a -&gt; ShowS
</span><a href="Data.Functor.Classes.html#showsUnaryWith"><span class="hs-identifier hs-var">showsUnaryWith</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679568286"><span class="hs-identifier hs-var">sp</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Solo&quot;</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679568285"><span class="hs-identifier hs-var">d</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568284"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-536"></span><span>
</span><span id="line-537"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-538"></span><span id="local-6989586621679568961"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568281"><span class="hs-special">(</span><span class="annot"><a href="GHC.Show.html#Show"><span class="hs-identifier hs-type">Show</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568961"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Show1"><span class="hs-identifier hs-type">Show1</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="hs-special">,</span><span class="hs-special">)</span><span> </span><span class="annot"><a href="#local-6989586621679568961"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-539"></span><span>    </span><span id="local-6989586621679568277"><span class="annot"><span class="annottext">liftShowsPrec :: forall a.
(Int -&gt; a -&gt; ShowS) -&gt; ([a] -&gt; ShowS) -&gt; Int -&gt; (a, a) -&gt; ShowS
</span><a href="#local-6989586621679568277"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftShowsPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS)
-&gt; (Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS)
-&gt; Int
-&gt; (a, a)
-&gt; ShowS
forall (f :: * -&gt; * -&gt; *) a b.
Show2 f =&gt;
(Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS)
-&gt; (Int -&gt; b -&gt; ShowS)
-&gt; ([b] -&gt; ShowS)
-&gt; Int
-&gt; f a b
-&gt; ShowS
</span><a href="Data.Functor.Classes.html#liftShowsPrec2"><span class="hs-identifier hs-var">liftShowsPrec2</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
forall a. Show a =&gt; Int -&gt; a -&gt; ShowS
</span><a href="GHC.Show.html#showsPrec"><span class="hs-identifier hs-var">showsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
forall a. Show a =&gt; [a] -&gt; ShowS
</span><a href="GHC.Show.html#showList"><span class="hs-identifier hs-var">showList</span></a></span></span><span>
</span><span id="line-540"></span><span>
</span><span id="line-541"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-542"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Eq2"><span class="hs-identifier hs-type">Eq2</span></a></span><span> </span><span class="annot"><a href="Data.Either.html#Either"><span class="hs-identifier hs-type">Either</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-543"></span><span>    </span><span id="local-6989586621679568274"><span class="annot"><span class="annottext">liftEq2 :: forall a b c d.
(a -&gt; b -&gt; Bool)
-&gt; (c -&gt; d -&gt; Bool) -&gt; Either a c -&gt; Either b d -&gt; Bool
</span><a href="#local-6989586621679568274"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftEq2</span></a></span></span><span> </span><span id="local-6989586621679568273"><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679568273"><span class="hs-identifier hs-var">e1</span></a></span></span><span> </span><span class="annot"><span class="annottext">c -&gt; d -&gt; Bool
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Left"><span class="hs-identifier hs-type">Left</span></a></span><span> </span><span id="local-6989586621679568272"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568272"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Left"><span class="hs-identifier hs-type">Left</span></a></span><span> </span><span id="local-6989586621679568271"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568271"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679568273"><span class="hs-identifier hs-var">e1</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568272"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568271"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-544"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftEq2"><span class="hs-identifier hs-var">liftEq2</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">c -&gt; d -&gt; Bool
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Left"><span class="hs-identifier hs-type">Left</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Right"><span class="hs-identifier hs-type">Right</span></a></span><span> </span><span class="annot"><span class="annottext">d
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../ghc-prim/src/GHC.Types.html#False"><span class="hs-identifier hs-var">False</span></a></span><span>
</span><span id="line-545"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftEq2"><span class="hs-identifier hs-var">liftEq2</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">c -&gt; d -&gt; Bool
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Right"><span class="hs-identifier hs-type">Right</span></a></span><span> </span><span class="annot"><span class="annottext">c
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Left"><span class="hs-identifier hs-type">Left</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../ghc-prim/src/GHC.Types.html#False"><span class="hs-identifier hs-var">False</span></a></span><span>
</span><span id="line-546"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftEq2"><span class="hs-identifier hs-var">liftEq2</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679568270"><span class="annot"><span class="annottext">c -&gt; d -&gt; Bool
</span><a href="#local-6989586621679568270"><span class="hs-identifier hs-var">e2</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Right"><span class="hs-identifier hs-type">Right</span></a></span><span> </span><span id="local-6989586621679568269"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679568269"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Right"><span class="hs-identifier hs-type">Right</span></a></span><span> </span><span id="local-6989586621679568268"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679568268"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">c -&gt; d -&gt; Bool
</span><a href="#local-6989586621679568270"><span class="hs-identifier hs-var">e2</span></a></span><span> </span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679568269"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679568268"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-547"></span><span>
</span><span id="line-548"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-549"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Ord2"><span class="hs-identifier hs-type">Ord2</span></a></span><span> </span><span class="annot"><a href="Data.Either.html#Either"><span class="hs-identifier hs-type">Either</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-550"></span><span>    </span><span id="local-6989586621679568263"><span class="annot"><span class="annottext">liftCompare2 :: forall a b c d.
(a -&gt; b -&gt; Ordering)
-&gt; (c -&gt; d -&gt; Ordering) -&gt; Either a c -&gt; Either b d -&gt; Ordering
</span><a href="#local-6989586621679568263"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftCompare2</span></a></span></span><span> </span><span id="local-6989586621679568262"><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679568262"><span class="hs-identifier hs-var">comp1</span></a></span></span><span> </span><span class="annot"><span class="annottext">c -&gt; d -&gt; Ordering
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Left"><span class="hs-identifier hs-type">Left</span></a></span><span> </span><span id="local-6989586621679568261"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568261"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Left"><span class="hs-identifier hs-type">Left</span></a></span><span> </span><span id="local-6989586621679568260"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568260"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679568262"><span class="hs-identifier hs-var">comp1</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568261"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568260"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-551"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftCompare2"><span class="hs-identifier hs-var">liftCompare2</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">c -&gt; d -&gt; Ordering
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Left"><span class="hs-identifier hs-type">Left</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Right"><span class="hs-identifier hs-type">Right</span></a></span><span> </span><span class="annot"><span class="annottext">d
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ordering
</span><a href="../../ghc-prim/src/GHC.Types.html#LT"><span class="hs-identifier hs-var">LT</span></a></span><span>
</span><span id="line-552"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftCompare2"><span class="hs-identifier hs-var">liftCompare2</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">c -&gt; d -&gt; Ordering
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Right"><span class="hs-identifier hs-type">Right</span></a></span><span> </span><span class="annot"><span class="annottext">c
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Left"><span class="hs-identifier hs-type">Left</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ordering
</span><a href="../../ghc-prim/src/GHC.Types.html#GT"><span class="hs-identifier hs-var">GT</span></a></span><span>
</span><span id="line-553"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftCompare2"><span class="hs-identifier hs-var">liftCompare2</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679568259"><span class="annot"><span class="annottext">c -&gt; d -&gt; Ordering
</span><a href="#local-6989586621679568259"><span class="hs-identifier hs-var">comp2</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Right"><span class="hs-identifier hs-type">Right</span></a></span><span> </span><span id="local-6989586621679568258"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679568258"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Right"><span class="hs-identifier hs-type">Right</span></a></span><span> </span><span id="local-6989586621679568257"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679568257"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">c -&gt; d -&gt; Ordering
</span><a href="#local-6989586621679568259"><span class="hs-identifier hs-var">comp2</span></a></span><span> </span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679568258"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679568257"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-554"></span><span>
</span><span id="line-555"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-556"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568255"><span class="annot"><a href="Data.Functor.Classes.html#Read2"><span class="hs-identifier hs-type">Read2</span></a></span><span> </span><span class="annot"><a href="Data.Either.html#Either"><span class="hs-identifier hs-type">Either</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-557"></span><span>    </span><span id="local-6989586621679568250"><span class="annot"><span class="annottext">liftReadPrec2 :: forall a b.
ReadPrec a
-&gt; ReadPrec [a]
-&gt; ReadPrec b
-&gt; ReadPrec [b]
-&gt; ReadPrec (Either a b)
</span><a href="#local-6989586621679568250"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadPrec2</span></a></span></span><span> </span><span id="local-6989586621679568249"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568249"><span class="hs-identifier hs-var">rp1</span></a></span></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679568248"><span class="annot"><span class="annottext">ReadPrec b
</span><a href="#local-6989586621679568248"><span class="hs-identifier hs-var">rp2</span></a></span></span><span> </span><span class="annot"><span class="annottext">ReadPrec [b]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (Either a b) -&gt; ReadPrec (Either a b)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="Data.Functor.Classes.html#readData"><span class="hs-identifier hs-var">readData</span></a></span><span> </span><span class="annot"><span class="annottext">(ReadPrec (Either a b) -&gt; ReadPrec (Either a b))
-&gt; ReadPrec (Either a b) -&gt; ReadPrec (Either a b)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-558"></span><span>         </span><span class="annot"><span class="annottext">ReadPrec a -&gt; String -&gt; (a -&gt; Either a b) -&gt; ReadPrec (Either a b)
forall a t. ReadPrec a -&gt; String -&gt; (a -&gt; t) -&gt; ReadPrec t
</span><a href="Data.Functor.Classes.html#readUnaryWith"><span class="hs-identifier hs-var">readUnaryWith</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568249"><span class="hs-identifier hs-var">rp1</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Left&quot;</span></span><span> </span><span class="annot"><span class="annottext">a -&gt; Either a b
forall a b. a -&gt; Either a b
</span><a href="Data.Either.html#Left"><span class="hs-identifier hs-var">Left</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec (Either a b)
-&gt; ReadPrec (Either a b) -&gt; ReadPrec (Either a b)
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span>
</span><span id="line-559"></span><span>         </span><span class="annot"><span class="annottext">ReadPrec b -&gt; String -&gt; (b -&gt; Either a b) -&gt; ReadPrec (Either a b)
forall a t. ReadPrec a -&gt; String -&gt; (a -&gt; t) -&gt; ReadPrec t
</span><a href="Data.Functor.Classes.html#readUnaryWith"><span class="hs-identifier hs-var">readUnaryWith</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec b
</span><a href="#local-6989586621679568248"><span class="hs-identifier hs-var">rp2</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Right&quot;</span></span><span> </span><span class="annot"><span class="annottext">b -&gt; Either a b
forall a b. b -&gt; Either a b
</span><a href="Data.Either.html#Right"><span class="hs-identifier hs-var">Right</span></a></span><span>
</span><span id="line-560"></span><span>
</span><span id="line-561"></span><span>    </span><span id="local-6989586621679568246"><span class="annot"><span class="annottext">liftReadListPrec2 :: forall a b.
ReadPrec a
-&gt; ReadPrec [a]
-&gt; ReadPrec b
-&gt; ReadPrec [b]
-&gt; ReadPrec [Either a b]
</span><a href="#local-6989586621679568246"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadListPrec2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a
-&gt; ReadPrec [a]
-&gt; ReadPrec b
-&gt; ReadPrec [b]
-&gt; ReadPrec [Either a b]
forall (f :: * -&gt; * -&gt; *) a b.
Read2 f =&gt;
ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec b -&gt; ReadPrec [b] -&gt; ReadPrec [f a b]
</span><a href="Data.Functor.Classes.html#liftReadListPrec2Default"><span class="hs-identifier hs-var">liftReadListPrec2Default</span></a></span><span>
</span><span id="line-562"></span><span>    </span><span id="local-6989586621679568244"><span class="annot"><span class="annottext">liftReadList2 :: forall a b.
(Int -&gt; ReadS a)
-&gt; ReadS [a] -&gt; (Int -&gt; ReadS b) -&gt; ReadS [b] -&gt; ReadS [Either a b]
</span><a href="#local-6989586621679568244"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadList2</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a)
-&gt; ReadS [a] -&gt; (Int -&gt; ReadS b) -&gt; ReadS [b] -&gt; ReadS [Either a b]
forall (f :: * -&gt; * -&gt; *) a b.
Read2 f =&gt;
(Int -&gt; ReadS a)
-&gt; ReadS [a] -&gt; (Int -&gt; ReadS b) -&gt; ReadS [b] -&gt; ReadS [f a b]
</span><a href="Data.Functor.Classes.html#liftReadList2Default"><span class="hs-identifier hs-var">liftReadList2Default</span></a></span><span>
</span><span id="line-563"></span><span>
</span><span id="line-564"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-565"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568241"><span class="annot"><a href="Data.Functor.Classes.html#Show2"><span class="hs-identifier hs-type">Show2</span></a></span><span> </span><span class="annot"><a href="Data.Either.html#Either"><span class="hs-identifier hs-type">Either</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-566"></span><span>    </span><span id="local-6989586621679568240"><span class="annot"><span class="annottext">liftShowsPrec2 :: forall a b.
(Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS)
-&gt; (Int -&gt; b -&gt; ShowS)
-&gt; ([b] -&gt; ShowS)
-&gt; Int
-&gt; Either a b
-&gt; ShowS
</span><a href="#local-6989586621679568240"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftShowsPrec2</span></a></span></span><span> </span><span id="local-6989586621679568239"><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679568239"><span class="hs-identifier hs-var">sp1</span></a></span></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Int -&gt; b -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">[b] -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679568238"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679568238"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Left"><span class="hs-identifier hs-type">Left</span></a></span><span> </span><span id="local-6989586621679568237"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568237"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; a -&gt; ShowS) -&gt; String -&gt; Int -&gt; a -&gt; ShowS
forall a. (Int -&gt; a -&gt; ShowS) -&gt; String -&gt; Int -&gt; a -&gt; ShowS
</span><a href="Data.Functor.Classes.html#showsUnaryWith"><span class="hs-identifier hs-var">showsUnaryWith</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679568239"><span class="hs-identifier hs-var">sp1</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Left&quot;</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679568238"><span class="hs-identifier hs-var">d</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568237"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-567"></span><span>    </span><span class="annot"><a href="Data.Functor.Classes.html#liftShowsPrec2"><span class="hs-identifier hs-var">liftShowsPrec2</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679568236"><span class="annot"><span class="annottext">Int -&gt; b -&gt; ShowS
</span><a href="#local-6989586621679568236"><span class="hs-identifier hs-var">sp2</span></a></span></span><span> </span><span class="annot"><span class="annottext">[b] -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679568235"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679568235"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Right"><span class="hs-identifier hs-type">Right</span></a></span><span> </span><span id="local-6989586621679568234"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568234"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; b -&gt; ShowS) -&gt; String -&gt; Int -&gt; b -&gt; ShowS
forall a. (Int -&gt; a -&gt; ShowS) -&gt; String -&gt; Int -&gt; a -&gt; ShowS
</span><a href="Data.Functor.Classes.html#showsUnaryWith"><span class="hs-identifier hs-var">showsUnaryWith</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; b -&gt; ShowS
</span><a href="#local-6989586621679568236"><span class="hs-identifier hs-var">sp2</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Right&quot;</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679568235"><span class="hs-identifier hs-var">d</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568234"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-568"></span><span>
</span><span id="line-569"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-570"></span><span id="local-6989586621679568940"><span class="hs-keyword">instance</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Classes.html#Eq"><span class="hs-identifier hs-type">Eq</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568940"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Eq1"><span class="hs-identifier hs-type">Eq1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Either"><span class="hs-identifier hs-type">Either</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568940"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-571"></span><span>    </span><span id="local-6989586621679568228"><span class="annot"><span class="annottext">liftEq :: forall a b. (a -&gt; b -&gt; Bool) -&gt; Either a a -&gt; Either a b -&gt; Bool
</span><a href="#local-6989586621679568228"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftEq</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; a -&gt; Bool)
-&gt; (a -&gt; b -&gt; Bool) -&gt; Either a a -&gt; Either a b -&gt; Bool
forall (f :: * -&gt; * -&gt; *) a b c d.
Eq2 f =&gt;
(a -&gt; b -&gt; Bool) -&gt; (c -&gt; d -&gt; Bool) -&gt; f a c -&gt; f b d -&gt; Bool
</span><a href="Data.Functor.Classes.html#liftEq2"><span class="hs-identifier hs-var">liftEq2</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">(==)</span></a></span></span><span>
</span><span id="line-572"></span><span>
</span><span id="line-573"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-574"></span><span id="local-6989586621679568936"><span class="hs-keyword">instance</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Classes.html#Ord"><span class="hs-identifier hs-type">Ord</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568936"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Ord1"><span class="hs-identifier hs-type">Ord1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Either"><span class="hs-identifier hs-type">Either</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568936"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-575"></span><span>    </span><span id="local-6989586621679568219"><span class="annot"><span class="annottext">liftCompare :: forall a b.
(a -&gt; b -&gt; Ordering) -&gt; Either a a -&gt; Either a b -&gt; Ordering
</span><a href="#local-6989586621679568219"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftCompare</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; a -&gt; Ordering)
-&gt; (a -&gt; b -&gt; Ordering) -&gt; Either a a -&gt; Either a b -&gt; Ordering
forall (f :: * -&gt; * -&gt; *) a b c d.
Ord2 f =&gt;
(a -&gt; b -&gt; Ordering)
-&gt; (c -&gt; d -&gt; Ordering) -&gt; f a c -&gt; f b d -&gt; Ordering
</span><a href="Data.Functor.Classes.html#liftCompare2"><span class="hs-identifier hs-var">liftCompare2</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Ordering
forall a. Ord a =&gt; a -&gt; a -&gt; Ordering
</span><a href="../../ghc-prim/src/GHC.Classes.html#compare"><span class="hs-identifier hs-var">compare</span></a></span></span><span>
</span><span id="line-576"></span><span>
</span><span id="line-577"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-578"></span><span id="local-6989586621679568933"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568217"><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568933"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Read1"><span class="hs-identifier hs-type">Read1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Either"><span class="hs-identifier hs-type">Either</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568933"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-579"></span><span>    </span><span id="local-6989586621679568210"><span class="annot"><span class="annottext">liftReadPrec :: forall a. ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec (Either a a)
</span><a href="#local-6989586621679568210"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a
-&gt; ReadPrec [a]
-&gt; ReadPrec a
-&gt; ReadPrec [a]
-&gt; ReadPrec (Either a a)
forall (f :: * -&gt; * -&gt; *) a b.
Read2 f =&gt;
ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec b -&gt; ReadPrec [b] -&gt; ReadPrec (f a b)
</span><a href="Data.Functor.Classes.html#liftReadPrec2"><span class="hs-identifier hs-var">liftReadPrec2</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrec"><span class="hs-identifier hs-var">readListPrec</span></a></span><span>
</span><span id="line-580"></span><span>
</span><span id="line-581"></span><span>    </span><span id="local-6989586621679568208"><span class="annot"><span class="annottext">liftReadListPrec :: forall a. ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [Either a a]
</span><a href="#local-6989586621679568208"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [Either a a]
forall (f :: * -&gt; *) a.
Read1 f =&gt;
ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [f a]
</span><a href="Data.Functor.Classes.html#liftReadListPrecDefault"><span class="hs-identifier hs-var">liftReadListPrecDefault</span></a></span><span>
</span><span id="line-582"></span><span>    </span><span id="local-6989586621679568206"><span class="annot"><span class="annottext">liftReadList :: forall a. (Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [Either a a]
</span><a href="#local-6989586621679568206"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [Either a a]
forall (f :: * -&gt; *) a.
Read1 f =&gt;
(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [f a]
</span><a href="Data.Functor.Classes.html#liftReadListDefault"><span class="hs-identifier hs-var">liftReadListDefault</span></a></span></span><span>
</span><span id="line-583"></span><span>
</span><span id="line-584"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-585"></span><span id="local-6989586621679568929"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568203"><span class="hs-special">(</span><span class="annot"><a href="GHC.Show.html#Show"><span class="hs-identifier hs-type">Show</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568929"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Show1"><span class="hs-identifier hs-type">Show1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Either.html#Either"><span class="hs-identifier hs-type">Either</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568929"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-586"></span><span>    </span><span id="local-6989586621679568199"><span class="annot"><span class="annottext">liftShowsPrec :: forall a.
(Int -&gt; a -&gt; ShowS) -&gt; ([a] -&gt; ShowS) -&gt; Int -&gt; Either a a -&gt; ShowS
</span><a href="#local-6989586621679568199"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftShowsPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS)
-&gt; (Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS)
-&gt; Int
-&gt; Either a a
-&gt; ShowS
forall (f :: * -&gt; * -&gt; *) a b.
Show2 f =&gt;
(Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS)
-&gt; (Int -&gt; b -&gt; ShowS)
-&gt; ([b] -&gt; ShowS)
-&gt; Int
-&gt; f a b
-&gt; ShowS
</span><a href="Data.Functor.Classes.html#liftShowsPrec2"><span class="hs-identifier hs-var">liftShowsPrec2</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
forall a. Show a =&gt; Int -&gt; a -&gt; ShowS
</span><a href="GHC.Show.html#showsPrec"><span class="hs-identifier hs-var">showsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
forall a. Show a =&gt; [a] -&gt; ShowS
</span><a href="GHC.Show.html#showList"><span class="hs-identifier hs-var">showList</span></a></span></span><span>
</span><span id="line-587"></span><span>
</span><span id="line-588"></span><span class="hs-comment">-- Instances for other functors defined in the base package</span><span>
</span><span id="line-589"></span><span>
</span><span id="line-590"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-591"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Eq1"><span class="hs-identifier hs-type">Eq1</span></a></span><span> </span><span class="annot"><a href="Data.Functor.Identity.html#Identity"><span class="hs-identifier hs-type">Identity</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-592"></span><span>    </span><span id="local-6989586621679568196"><span class="annot"><span class="annottext">liftEq :: forall a b. (a -&gt; b -&gt; Bool) -&gt; Identity a -&gt; Identity b -&gt; Bool
</span><a href="#local-6989586621679568196"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftEq</span></a></span></span><span> </span><span id="local-6989586621679568195"><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679568195"><span class="hs-identifier hs-var">eq</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Identity.html#Identity"><span class="hs-identifier hs-type">Identity</span></a></span><span> </span><span id="local-6989586621679568194"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568194"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Identity.html#Identity"><span class="hs-identifier hs-type">Identity</span></a></span><span> </span><span id="local-6989586621679568193"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568193"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679568195"><span class="hs-identifier hs-var">eq</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568194"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568193"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-593"></span><span>
</span><span id="line-594"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-595"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Ord1"><span class="hs-identifier hs-type">Ord1</span></a></span><span> </span><span class="annot"><a href="Data.Functor.Identity.html#Identity"><span class="hs-identifier hs-type">Identity</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-596"></span><span>    </span><span id="local-6989586621679568188"><span class="annot"><span class="annottext">liftCompare :: forall a b.
(a -&gt; b -&gt; Ordering) -&gt; Identity a -&gt; Identity b -&gt; Ordering
</span><a href="#local-6989586621679568188"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftCompare</span></a></span></span><span> </span><span id="local-6989586621679568187"><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679568187"><span class="hs-identifier hs-var">comp</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Identity.html#Identity"><span class="hs-identifier hs-type">Identity</span></a></span><span> </span><span id="local-6989586621679568186"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568186"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Identity.html#Identity"><span class="hs-identifier hs-type">Identity</span></a></span><span> </span><span id="local-6989586621679568185"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568185"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679568187"><span class="hs-identifier hs-var">comp</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568186"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568185"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-597"></span><span>
</span><span id="line-598"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-599"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568183"><span class="annot"><a href="Data.Functor.Classes.html#Read1"><span class="hs-identifier hs-type">Read1</span></a></span><span> </span><span class="annot"><a href="Data.Functor.Identity.html#Identity"><span class="hs-identifier hs-type">Identity</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-600"></span><span>    </span><span id="local-6989586621679568179"><span class="annot"><span class="annottext">liftReadPrec :: forall a. ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec (Identity a)
</span><a href="#local-6989586621679568179"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadPrec</span></a></span></span><span> </span><span id="local-6989586621679568178"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568178"><span class="hs-identifier hs-var">rp</span></a></span></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (Identity a) -&gt; ReadPrec (Identity a)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="Data.Functor.Classes.html#readData"><span class="hs-identifier hs-var">readData</span></a></span><span> </span><span class="annot"><span class="annottext">(ReadPrec (Identity a) -&gt; ReadPrec (Identity a))
-&gt; ReadPrec (Identity a) -&gt; ReadPrec (Identity a)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-601"></span><span>         </span><span class="annot"><span class="annottext">ReadPrec a -&gt; String -&gt; (a -&gt; Identity a) -&gt; ReadPrec (Identity a)
forall a t. ReadPrec a -&gt; String -&gt; (a -&gt; t) -&gt; ReadPrec t
</span><a href="Data.Functor.Classes.html#readUnaryWith"><span class="hs-identifier hs-var">readUnaryWith</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568178"><span class="hs-identifier hs-var">rp</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Identity&quot;</span></span><span> </span><span class="annot"><span class="annottext">a -&gt; Identity a
forall a. a -&gt; Identity a
</span><a href="Data.Functor.Identity.html#Identity"><span class="hs-identifier hs-var">Identity</span></a></span><span>
</span><span id="line-602"></span><span>
</span><span id="line-603"></span><span>    </span><span id="local-6989586621679568176"><span class="annot"><span class="annottext">liftReadListPrec :: forall a. ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [Identity a]
</span><a href="#local-6989586621679568176"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [Identity a]
forall (f :: * -&gt; *) a.
Read1 f =&gt;
ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [f a]
</span><a href="Data.Functor.Classes.html#liftReadListPrecDefault"><span class="hs-identifier hs-var">liftReadListPrecDefault</span></a></span><span>
</span><span id="line-604"></span><span>    </span><span id="local-6989586621679568174"><span class="annot"><span class="annottext">liftReadList :: forall a. (Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [Identity a]
</span><a href="#local-6989586621679568174"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [Identity a]
forall (f :: * -&gt; *) a.
Read1 f =&gt;
(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [f a]
</span><a href="Data.Functor.Classes.html#liftReadListDefault"><span class="hs-identifier hs-var">liftReadListDefault</span></a></span><span>
</span><span id="line-605"></span><span>
</span><span id="line-606"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-607"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568171"><span class="annot"><a href="Data.Functor.Classes.html#Show1"><span class="hs-identifier hs-type">Show1</span></a></span><span> </span><span class="annot"><a href="Data.Functor.Identity.html#Identity"><span class="hs-identifier hs-type">Identity</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-608"></span><span>    </span><span id="local-6989586621679568170"><span class="annot"><span class="annottext">liftShowsPrec :: forall a.
(Int -&gt; a -&gt; ShowS) -&gt; ([a] -&gt; ShowS) -&gt; Int -&gt; Identity a -&gt; ShowS
</span><a href="#local-6989586621679568170"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftShowsPrec</span></a></span></span><span> </span><span id="local-6989586621679568169"><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679568169"><span class="hs-identifier hs-var">sp</span></a></span></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679568168"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679568168"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Identity.html#Identity"><span class="hs-identifier hs-type">Identity</span></a></span><span> </span><span id="local-6989586621679568167"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568167"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; a -&gt; ShowS) -&gt; String -&gt; Int -&gt; a -&gt; ShowS
forall a. (Int -&gt; a -&gt; ShowS) -&gt; String -&gt; Int -&gt; a -&gt; ShowS
</span><a href="Data.Functor.Classes.html#showsUnaryWith"><span class="hs-identifier hs-var">showsUnaryWith</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679568169"><span class="hs-identifier hs-var">sp</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Identity&quot;</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679568168"><span class="hs-identifier hs-var">d</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568167"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-609"></span><span>
</span><span id="line-610"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-611"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Eq2"><span class="hs-identifier hs-type">Eq2</span></a></span><span> </span><span class="annot"><a href="Data.Functor.Const.html#Const"><span class="hs-identifier hs-type">Const</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-612"></span><span>    </span><span id="local-6989586621679568164"><span class="annot"><span class="annottext">liftEq2 :: forall a b c d.
(a -&gt; b -&gt; Bool)
-&gt; (c -&gt; d -&gt; Bool) -&gt; Const a c -&gt; Const b d -&gt; Bool
</span><a href="#local-6989586621679568164"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftEq2</span></a></span></span><span> </span><span id="local-6989586621679568163"><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679568163"><span class="hs-identifier hs-var">eq</span></a></span></span><span> </span><span class="annot"><span class="annottext">c -&gt; d -&gt; Bool
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Const.html#Const"><span class="hs-identifier hs-type">Const</span></a></span><span> </span><span id="local-6989586621679568162"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568162"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Const.html#Const"><span class="hs-identifier hs-type">Const</span></a></span><span> </span><span id="local-6989586621679568161"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568161"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679568163"><span class="hs-identifier hs-var">eq</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568162"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568161"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-613"></span><span>
</span><span id="line-614"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-615"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Ord2"><span class="hs-identifier hs-type">Ord2</span></a></span><span> </span><span class="annot"><a href="Data.Functor.Const.html#Const"><span class="hs-identifier hs-type">Const</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-616"></span><span>    </span><span id="local-6989586621679568156"><span class="annot"><span class="annottext">liftCompare2 :: forall a b c d.
(a -&gt; b -&gt; Ordering)
-&gt; (c -&gt; d -&gt; Ordering) -&gt; Const a c -&gt; Const b d -&gt; Ordering
</span><a href="#local-6989586621679568156"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftCompare2</span></a></span></span><span> </span><span id="local-6989586621679568155"><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679568155"><span class="hs-identifier hs-var">comp</span></a></span></span><span> </span><span class="annot"><span class="annottext">c -&gt; d -&gt; Ordering
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Const.html#Const"><span class="hs-identifier hs-type">Const</span></a></span><span> </span><span id="local-6989586621679568154"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568154"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Const.html#Const"><span class="hs-identifier hs-type">Const</span></a></span><span> </span><span id="local-6989586621679568153"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568153"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679568155"><span class="hs-identifier hs-var">comp</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568154"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568153"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-617"></span><span>
</span><span id="line-618"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-619"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568151"><span class="annot"><a href="Data.Functor.Classes.html#Read2"><span class="hs-identifier hs-type">Read2</span></a></span><span> </span><span class="annot"><a href="Data.Functor.Const.html#Const"><span class="hs-identifier hs-type">Const</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-620"></span><span>    </span><span id="local-6989586621679568147"><span class="annot"><span class="annottext">liftReadPrec2 :: forall a b.
ReadPrec a
-&gt; ReadPrec [a]
-&gt; ReadPrec b
-&gt; ReadPrec [b]
-&gt; ReadPrec (Const a b)
</span><a href="#local-6989586621679568147"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadPrec2</span></a></span></span><span> </span><span id="local-6989586621679568146"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568146"><span class="hs-identifier hs-var">rp</span></a></span></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">ReadPrec b
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">ReadPrec [b]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (Const a b) -&gt; ReadPrec (Const a b)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="Data.Functor.Classes.html#readData"><span class="hs-identifier hs-var">readData</span></a></span><span> </span><span class="annot"><span class="annottext">(ReadPrec (Const a b) -&gt; ReadPrec (Const a b))
-&gt; ReadPrec (Const a b) -&gt; ReadPrec (Const a b)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-621"></span><span>         </span><span class="annot"><span class="annottext">ReadPrec a -&gt; String -&gt; (a -&gt; Const a b) -&gt; ReadPrec (Const a b)
forall a t. ReadPrec a -&gt; String -&gt; (a -&gt; t) -&gt; ReadPrec t
</span><a href="Data.Functor.Classes.html#readUnaryWith"><span class="hs-identifier hs-var">readUnaryWith</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568146"><span class="hs-identifier hs-var">rp</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Const&quot;</span></span><span> </span><span class="annot"><span class="annottext">a -&gt; Const a b
forall {k} a (b :: k). a -&gt; Const a b
</span><a href="Data.Functor.Const.html#Const"><span class="hs-identifier hs-var">Const</span></a></span><span>
</span><span id="line-622"></span><span>
</span><span id="line-623"></span><span>    </span><span id="local-6989586621679568144"><span class="annot"><span class="annottext">liftReadListPrec2 :: forall a b.
ReadPrec a
-&gt; ReadPrec [a]
-&gt; ReadPrec b
-&gt; ReadPrec [b]
-&gt; ReadPrec [Const a b]
</span><a href="#local-6989586621679568144"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadListPrec2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a
-&gt; ReadPrec [a]
-&gt; ReadPrec b
-&gt; ReadPrec [b]
-&gt; ReadPrec [Const a b]
forall (f :: * -&gt; * -&gt; *) a b.
Read2 f =&gt;
ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec b -&gt; ReadPrec [b] -&gt; ReadPrec [f a b]
</span><a href="Data.Functor.Classes.html#liftReadListPrec2Default"><span class="hs-identifier hs-var">liftReadListPrec2Default</span></a></span><span>
</span><span id="line-624"></span><span>    </span><span id="local-6989586621679568142"><span class="annot"><span class="annottext">liftReadList2 :: forall a b.
(Int -&gt; ReadS a)
-&gt; ReadS [a] -&gt; (Int -&gt; ReadS b) -&gt; ReadS [b] -&gt; ReadS [Const a b]
</span><a href="#local-6989586621679568142"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadList2</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a)
-&gt; ReadS [a] -&gt; (Int -&gt; ReadS b) -&gt; ReadS [b] -&gt; ReadS [Const a b]
forall (f :: * -&gt; * -&gt; *) a b.
Read2 f =&gt;
(Int -&gt; ReadS a)
-&gt; ReadS [a] -&gt; (Int -&gt; ReadS b) -&gt; ReadS [b] -&gt; ReadS [f a b]
</span><a href="Data.Functor.Classes.html#liftReadList2Default"><span class="hs-identifier hs-var">liftReadList2Default</span></a></span><span>
</span><span id="line-625"></span><span>
</span><span id="line-626"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-627"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568139"><span class="annot"><a href="Data.Functor.Classes.html#Show2"><span class="hs-identifier hs-type">Show2</span></a></span><span> </span><span class="annot"><a href="Data.Functor.Const.html#Const"><span class="hs-identifier hs-type">Const</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-628"></span><span>    </span><span id="local-6989586621679568138"><span class="annot"><span class="annottext">liftShowsPrec2 :: forall a b.
(Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS)
-&gt; (Int -&gt; b -&gt; ShowS)
-&gt; ([b] -&gt; ShowS)
-&gt; Int
-&gt; Const a b
-&gt; ShowS
</span><a href="#local-6989586621679568138"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftShowsPrec2</span></a></span></span><span> </span><span id="local-6989586621679568137"><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679568137"><span class="hs-identifier hs-var">sp</span></a></span></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Int -&gt; b -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">[b] -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679568136"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679568136"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Const.html#Const"><span class="hs-identifier hs-type">Const</span></a></span><span> </span><span id="local-6989586621679568135"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568135"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; a -&gt; ShowS) -&gt; String -&gt; Int -&gt; a -&gt; ShowS
forall a. (Int -&gt; a -&gt; ShowS) -&gt; String -&gt; Int -&gt; a -&gt; ShowS
</span><a href="Data.Functor.Classes.html#showsUnaryWith"><span class="hs-identifier hs-var">showsUnaryWith</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679568137"><span class="hs-identifier hs-var">sp</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Const&quot;</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679568136"><span class="hs-identifier hs-var">d</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568135"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-629"></span><span>
</span><span id="line-630"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-631"></span><span id="local-6989586621679568898"><span class="hs-keyword">instance</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Classes.html#Eq"><span class="hs-identifier hs-type">Eq</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568898"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Eq1"><span class="hs-identifier hs-type">Eq1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Const.html#Const"><span class="hs-identifier hs-type">Const</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568898"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-632"></span><span>    </span><span id="local-6989586621679568129"><span class="annot"><span class="annottext">liftEq :: forall a b. (a -&gt; b -&gt; Bool) -&gt; Const a a -&gt; Const a b -&gt; Bool
</span><a href="#local-6989586621679568129"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftEq</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; a -&gt; Bool)
-&gt; (a -&gt; b -&gt; Bool) -&gt; Const a a -&gt; Const a b -&gt; Bool
forall (f :: * -&gt; * -&gt; *) a b c d.
Eq2 f =&gt;
(a -&gt; b -&gt; Bool) -&gt; (c -&gt; d -&gt; Bool) -&gt; f a c -&gt; f b d -&gt; Bool
</span><a href="Data.Functor.Classes.html#liftEq2"><span class="hs-identifier hs-var">liftEq2</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">(==)</span></a></span></span><span>
</span><span id="line-633"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-634"></span><span id="local-6989586621679568894"><span class="hs-keyword">instance</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Classes.html#Ord"><span class="hs-identifier hs-type">Ord</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568894"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Ord1"><span class="hs-identifier hs-type">Ord1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Const.html#Const"><span class="hs-identifier hs-type">Const</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568894"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-635"></span><span>    </span><span id="local-6989586621679568120"><span class="annot"><span class="annottext">liftCompare :: forall a b.
(a -&gt; b -&gt; Ordering) -&gt; Const a a -&gt; Const a b -&gt; Ordering
</span><a href="#local-6989586621679568120"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftCompare</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; a -&gt; Ordering)
-&gt; (a -&gt; b -&gt; Ordering) -&gt; Const a a -&gt; Const a b -&gt; Ordering
forall (f :: * -&gt; * -&gt; *) a b c d.
Ord2 f =&gt;
(a -&gt; b -&gt; Ordering)
-&gt; (c -&gt; d -&gt; Ordering) -&gt; f a c -&gt; f b d -&gt; Ordering
</span><a href="Data.Functor.Classes.html#liftCompare2"><span class="hs-identifier hs-var">liftCompare2</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Ordering
forall a. Ord a =&gt; a -&gt; a -&gt; Ordering
</span><a href="../../ghc-prim/src/GHC.Classes.html#compare"><span class="hs-identifier hs-var">compare</span></a></span></span><span>
</span><span id="line-636"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-637"></span><span id="local-6989586621679568891"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568118"><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568891"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Read1"><span class="hs-identifier hs-type">Read1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Const.html#Const"><span class="hs-identifier hs-type">Const</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568891"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-638"></span><span>    </span><span id="local-6989586621679568111"><span class="annot"><span class="annottext">liftReadPrec :: forall a. ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec (Const a a)
</span><a href="#local-6989586621679568111"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a
-&gt; ReadPrec [a]
-&gt; ReadPrec a
-&gt; ReadPrec [a]
-&gt; ReadPrec (Const a a)
forall (f :: * -&gt; * -&gt; *) a b.
Read2 f =&gt;
ReadPrec a
-&gt; ReadPrec [a] -&gt; ReadPrec b -&gt; ReadPrec [b] -&gt; ReadPrec (f a b)
</span><a href="Data.Functor.Classes.html#liftReadPrec2"><span class="hs-identifier hs-var">liftReadPrec2</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrec"><span class="hs-identifier hs-var">readListPrec</span></a></span><span>
</span><span id="line-639"></span><span>
</span><span id="line-640"></span><span>    </span><span id="local-6989586621679568109"><span class="annot"><span class="annottext">liftReadListPrec :: forall a. ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [Const a a]
</span><a href="#local-6989586621679568109"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [Const a a]
forall (f :: * -&gt; *) a.
Read1 f =&gt;
ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [f a]
</span><a href="Data.Functor.Classes.html#liftReadListPrecDefault"><span class="hs-identifier hs-var">liftReadListPrecDefault</span></a></span><span>
</span><span id="line-641"></span><span>    </span><span id="local-6989586621679568107"><span class="annot"><span class="annottext">liftReadList :: forall a. (Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [Const a a]
</span><a href="#local-6989586621679568107"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [Const a a]
forall (f :: * -&gt; *) a.
Read1 f =&gt;
(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [f a]
</span><a href="Data.Functor.Classes.html#liftReadListDefault"><span class="hs-identifier hs-var">liftReadListDefault</span></a></span></span><span>
</span><span id="line-642"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-643"></span><span id="local-6989586621679568887"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568104"><span class="hs-special">(</span><span class="annot"><a href="GHC.Show.html#Show"><span class="hs-identifier hs-type">Show</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568887"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Show1"><span class="hs-identifier hs-type">Show1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Const.html#Const"><span class="hs-identifier hs-type">Const</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568887"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-644"></span><span>    </span><span id="local-6989586621679568100"><span class="annot"><span class="annottext">liftShowsPrec :: forall a.
(Int -&gt; a -&gt; ShowS) -&gt; ([a] -&gt; ShowS) -&gt; Int -&gt; Const a a -&gt; ShowS
</span><a href="#local-6989586621679568100"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftShowsPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS)
-&gt; (Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS)
-&gt; Int
-&gt; Const a a
-&gt; ShowS
forall (f :: * -&gt; * -&gt; *) a b.
Show2 f =&gt;
(Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS)
-&gt; (Int -&gt; b -&gt; ShowS)
-&gt; ([b] -&gt; ShowS)
-&gt; Int
-&gt; f a b
-&gt; ShowS
</span><a href="Data.Functor.Classes.html#liftShowsPrec2"><span class="hs-identifier hs-var">liftShowsPrec2</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
forall a. Show a =&gt; Int -&gt; a -&gt; ShowS
</span><a href="GHC.Show.html#showsPrec"><span class="hs-identifier hs-var">showsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
forall a. Show a =&gt; [a] -&gt; ShowS
</span><a href="GHC.Show.html#showList"><span class="hs-identifier hs-var">showList</span></a></span></span><span>
</span><span id="line-645"></span><span>
</span><span id="line-646"></span><span class="hs-comment">-- Proxy unfortunately imports this module, hence these instances are placed</span><span>
</span><span id="line-647"></span><span class="hs-comment">-- here,</span><span>
</span><span id="line-648"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-649"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Eq1"><span class="hs-identifier hs-type">Eq1</span></a></span><span> </span><span class="annot"><a href="Data.Proxy.html#Proxy"><span class="hs-identifier hs-type">Proxy</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-650"></span><span>  </span><span id="local-6989586621679568097"><span class="annot"><span class="annottext">liftEq :: forall a b. (a -&gt; b -&gt; Bool) -&gt; Proxy a -&gt; Proxy b -&gt; Bool
</span><a href="#local-6989586621679568097"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftEq</span></a></span></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Proxy a
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Proxy b
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../ghc-prim/src/GHC.Types.html#True"><span class="hs-identifier hs-var">True</span></a></span><span>
</span><span id="line-651"></span><span>
</span><span id="line-652"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-653"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Ord1"><span class="hs-identifier hs-type">Ord1</span></a></span><span> </span><span class="annot"><a href="Data.Proxy.html#Proxy"><span class="hs-identifier hs-type">Proxy</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-654"></span><span>  </span><span id="local-6989586621679568092"><span class="annot"><span class="annottext">liftCompare :: forall a b. (a -&gt; b -&gt; Ordering) -&gt; Proxy a -&gt; Proxy b -&gt; Ordering
</span><a href="#local-6989586621679568092"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftCompare</span></a></span></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Proxy a
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Proxy b
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ordering
</span><a href="../../ghc-prim/src/GHC.Types.html#EQ"><span class="hs-identifier hs-var">EQ</span></a></span><span>
</span><span id="line-655"></span><span>
</span><span id="line-656"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-657"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568089"><span class="annot"><a href="Data.Functor.Classes.html#Show1"><span class="hs-identifier hs-type">Show1</span></a></span><span> </span><span class="annot"><a href="Data.Proxy.html#Proxy"><span class="hs-identifier hs-type">Proxy</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-658"></span><span>  </span><span id="local-6989586621679568088"><span class="annot"><span class="annottext">liftShowsPrec :: forall a.
(Int -&gt; a -&gt; ShowS) -&gt; ([a] -&gt; ShowS) -&gt; Int -&gt; Proxy a -&gt; ShowS
</span><a href="#local-6989586621679568088"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftShowsPrec</span></a></span></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Proxy a
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; ShowS
</span><a href="GHC.Show.html#showString"><span class="hs-identifier hs-var">showString</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Proxy&quot;</span></span><span>
</span><span id="line-659"></span><span>
</span><span id="line-660"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-661"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568086"><span class="annot"><a href="Data.Functor.Classes.html#Read1"><span class="hs-identifier hs-type">Read1</span></a></span><span> </span><span class="annot"><a href="Data.Proxy.html#Proxy"><span class="hs-identifier hs-type">Proxy</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-662"></span><span>  </span><span id="local-6989586621679568080"><span class="annot"><span class="annottext">liftReadPrec :: forall a. ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec (Proxy a)
</span><a href="#local-6989586621679568080"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadPrec</span></a></span></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (Proxy a) -&gt; ReadPrec (Proxy a)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#parens"><span class="hs-identifier hs-var">parens</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var">expectP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Lexeme
</span><a href="Text.Read.Lex.html#Ident"><span class="hs-identifier hs-var">Ident</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Proxy&quot;</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ReadPrec () -&gt; ReadPrec (Proxy a) -&gt; ReadPrec (Proxy a)
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Proxy a -&gt; ReadPrec (Proxy a)
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">Proxy a
forall {k} (t :: k). Proxy t
</span><a href="Data.Proxy.html#Proxy"><span class="hs-identifier hs-var">Proxy</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-663"></span><span>
</span><span id="line-664"></span><span>  </span><span id="local-6989586621679568078"><span class="annot"><span class="annottext">liftReadListPrec :: forall a. ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [Proxy a]
</span><a href="#local-6989586621679568078"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [Proxy a]
forall (f :: * -&gt; *) a.
Read1 f =&gt;
ReadPrec a -&gt; ReadPrec [a] -&gt; ReadPrec [f a]
</span><a href="Data.Functor.Classes.html#liftReadListPrecDefault"><span class="hs-identifier hs-var">liftReadListPrecDefault</span></a></span><span>
</span><span id="line-665"></span><span>  </span><span id="local-6989586621679568076"><span class="annot"><span class="annottext">liftReadList :: forall a. (Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [Proxy a]
</span><a href="#local-6989586621679568076"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [Proxy a]
forall (f :: * -&gt; *) a.
Read1 f =&gt;
(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; ReadS [f a]
</span><a href="Data.Functor.Classes.html#liftReadListDefault"><span class="hs-identifier hs-var">liftReadListDefault</span></a></span><span>
</span><span id="line-666"></span><span>
</span><span id="line-667"></span><span class="hs-comment">-- | @since 4.12.0.0</span><span>
</span><span id="line-668"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Eq1"><span class="hs-identifier hs-type">Eq1</span></a></span><span> </span><span class="annot"><a href="Data.Ord.html#Down"><span class="hs-identifier hs-type">Down</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-669"></span><span>    </span><span id="local-6989586621679568073"><span class="annot"><span class="annottext">liftEq :: forall a b. (a -&gt; b -&gt; Bool) -&gt; Down a -&gt; Down b -&gt; Bool
</span><a href="#local-6989586621679568073"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftEq</span></a></span></span><span> </span><span id="local-6989586621679568072"><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679568072"><span class="hs-identifier hs-var">eq</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Ord.html#Down"><span class="hs-identifier hs-type">Down</span></a></span><span> </span><span id="local-6989586621679568071"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568071"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Ord.html#Down"><span class="hs-identifier hs-type">Down</span></a></span><span> </span><span id="local-6989586621679568070"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568070"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679568072"><span class="hs-identifier hs-var">eq</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568071"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568070"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-670"></span><span>
</span><span id="line-671"></span><span class="hs-comment">-- | @since 4.12.0.0</span><span>
</span><span id="line-672"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Ord1"><span class="hs-identifier hs-type">Ord1</span></a></span><span> </span><span class="annot"><a href="Data.Ord.html#Down"><span class="hs-identifier hs-type">Down</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-673"></span><span>    </span><span id="local-6989586621679568065"><span class="annot"><span class="annottext">liftCompare :: forall a b. (a -&gt; b -&gt; Ordering) -&gt; Down a -&gt; Down b -&gt; Ordering
</span><a href="#local-6989586621679568065"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftCompare</span></a></span></span><span> </span><span id="local-6989586621679568064"><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679568064"><span class="hs-identifier hs-var">comp</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Ord.html#Down"><span class="hs-identifier hs-type">Down</span></a></span><span> </span><span id="local-6989586621679568063"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568063"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Ord.html#Down"><span class="hs-identifier hs-type">Down</span></a></span><span> </span><span id="local-6989586621679568062"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568062"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679568064"><span class="hs-identifier hs-var">comp</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568063"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568062"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-674"></span><span>
</span><span id="line-675"></span><span class="hs-comment">-- | @since 4.12.0.0</span><span>
</span><span id="line-676"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568055"><span id="local-6989586621679568057"><span id="local-6989586621679568059"><span class="annot"><a href="Data.Functor.Classes.html#Read1"><span class="hs-identifier hs-type">Read1</span></a></span><span> </span><span class="annot"><a href="Data.Ord.html#Down"><span class="hs-identifier hs-type">Down</span></a></span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-677"></span><span>    </span><span id="local-6989586621679568054"><span class="annot"><span class="annottext">liftReadsPrec :: forall a. (Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; Int -&gt; ReadS (Down a)
</span><a href="#local-6989586621679568054"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadsPrec</span></a></span></span><span> </span><span id="local-6989586621679568053"><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679568053"><span class="hs-identifier hs-var">rp</span></a></span></span><span> </span><span class="annot"><span class="annottext">ReadS [a]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(String -&gt; ReadS (Down a)) -&gt; Int -&gt; ReadS (Down a)
forall a. (String -&gt; ReadS a) -&gt; Int -&gt; ReadS a
</span><a href="Data.Functor.Classes.html#readsData"><span class="hs-identifier hs-var">readsData</span></a></span><span> </span><span class="annot"><span class="annottext">((String -&gt; ReadS (Down a)) -&gt; Int -&gt; ReadS (Down a))
-&gt; (String -&gt; ReadS (Down a)) -&gt; Int -&gt; ReadS (Down a)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-678"></span><span>         </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a)
-&gt; String -&gt; (a -&gt; Down a) -&gt; String -&gt; ReadS (Down a)
forall a t.
(Int -&gt; ReadS a) -&gt; String -&gt; (a -&gt; t) -&gt; String -&gt; ReadS t
</span><a href="Data.Functor.Classes.html#readsUnaryWith"><span class="hs-identifier hs-var">readsUnaryWith</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679568053"><span class="hs-identifier hs-var">rp</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Down&quot;</span></span><span> </span><span class="annot"><span class="annottext">a -&gt; Down a
forall a. a -&gt; Down a
</span><a href="Data.Ord.html#Down"><span class="hs-identifier hs-var">Down</span></a></span><span>
</span><span id="line-679"></span><span>
</span><span id="line-680"></span><span class="hs-comment">-- | @since 4.12.0.0</span><span>
</span><span id="line-681"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679568050"><span class="annot"><a href="Data.Functor.Classes.html#Show1"><span class="hs-identifier hs-type">Show1</span></a></span><span> </span><span class="annot"><a href="Data.Ord.html#Down"><span class="hs-identifier hs-type">Down</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-682"></span><span>    </span><span id="local-6989586621679568049"><span class="annot"><span class="annottext">liftShowsPrec :: forall a.
(Int -&gt; a -&gt; ShowS) -&gt; ([a] -&gt; ShowS) -&gt; Int -&gt; Down a -&gt; ShowS
</span><a href="#local-6989586621679568049"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftShowsPrec</span></a></span></span><span> </span><span id="local-6989586621679568048"><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679568048"><span class="hs-identifier hs-var">sp</span></a></span></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679568047"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679568047"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Ord.html#Down"><span class="hs-identifier hs-type">Down</span></a></span><span> </span><span id="local-6989586621679568046"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568046"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; a -&gt; ShowS) -&gt; String -&gt; Int -&gt; a -&gt; ShowS
forall a. (Int -&gt; a -&gt; ShowS) -&gt; String -&gt; Int -&gt; a -&gt; ShowS
</span><a href="Data.Functor.Classes.html#showsUnaryWith"><span class="hs-identifier hs-var">showsUnaryWith</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679568048"><span class="hs-identifier hs-var">sp</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Down&quot;</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679568047"><span class="hs-identifier hs-var">d</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568046"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-683"></span><span>
</span><span id="line-684"></span><span>
</span><span id="line-685"></span><span class="hs-comment">-- Building blocks</span><span>
</span><span id="line-686"></span><span>
</span><span id="line-687"></span><span class="hs-comment">-- | @'readsData' p d@ is a parser for datatypes where each alternative</span><span>
</span><span id="line-688"></span><span class="hs-comment">-- begins with a data constructor.  It parses the constructor and</span><span>
</span><span id="line-689"></span><span class="hs-comment">-- passes it to @p@.  Parsers for various constructors can be constructed</span><span>
</span><span id="line-690"></span><span class="hs-comment">-- with 'readsUnary', 'readsUnary1' and 'readsBinary1', and combined with</span><span>
</span><span id="line-691"></span><span class="hs-comment">-- @mappend@ from the @Monoid@ class.</span><span>
</span><span id="line-692"></span><span class="hs-comment">--</span><span>
</span><span id="line-693"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-694"></span><span id="local-6989586621679568870"><span class="annot"><a href="Data.Functor.Classes.html#readsData"><span class="hs-identifier hs-type">readsData</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568870"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568870"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-695"></span><span id="readsData"><span class="annot"><span class="annottext">readsData :: forall a. (String -&gt; ReadS a) -&gt; Int -&gt; ReadS a
</span><a href="Data.Functor.Classes.html#readsData"><span class="hs-identifier hs-var hs-var">readsData</span></a></span></span><span> </span><span id="local-6989586621679568043"><span class="annot"><span class="annottext">String -&gt; ReadS a
</span><a href="#local-6989586621679568043"><span class="hs-identifier hs-var">reader</span></a></span></span><span> </span><span id="local-6989586621679568042"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679568042"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-696"></span><span>    </span><span class="annot"><span class="annottext">Bool -&gt; ReadS a -&gt; ReadS a
forall a. Bool -&gt; ReadS a -&gt; ReadS a
</span><a href="GHC.Read.html#readParen"><span class="hs-identifier hs-var">readParen</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679568042"><span class="hs-identifier hs-var">d</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E"><span class="hs-operator hs-var">&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">10</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(ReadS a -&gt; ReadS a) -&gt; ReadS a -&gt; ReadS a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span> </span><span id="local-6989586621679568041"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568041"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">(a, String)
</span><a href="#local-6989586621679568040"><span class="hs-identifier hs-var">res</span></a></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679568039"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568039"><span class="hs-identifier hs-var">kw</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679568038"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568038"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadS String
</span><a href="GHC.Read.html#lex"><span class="hs-identifier hs-var">lex</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568041"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679568040"><span class="annot"><span class="annottext">(a, String)
</span><a href="#local-6989586621679568040"><span class="hs-identifier hs-var">res</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">String -&gt; ReadS a
</span><a href="#local-6989586621679568043"><span class="hs-identifier hs-var">reader</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568039"><span class="hs-identifier hs-var">kw</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568038"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-697"></span><span>
</span><span id="line-698"></span><span class="hs-comment">-- | @'readData' p@ is a parser for datatypes where each alternative</span><span>
</span><span id="line-699"></span><span class="hs-comment">-- begins with a data constructor.  It parses the constructor and</span><span>
</span><span id="line-700"></span><span class="hs-comment">-- passes it to @p@.  Parsers for various constructors can be constructed</span><span>
</span><span id="line-701"></span><span class="hs-comment">-- with 'readUnaryWith' and 'readBinaryWith', and combined with</span><span>
</span><span id="line-702"></span><span class="hs-comment">-- '(&lt;|&gt;)' from the 'Alternative' class.</span><span>
</span><span id="line-703"></span><span class="hs-comment">--</span><span>
</span><span id="line-704"></span><span class="hs-comment">-- @since 4.10.0.0</span><span>
</span><span id="line-705"></span><span id="local-6989586621679568037"><span class="annot"><a href="Data.Functor.Classes.html#readData"><span class="hs-identifier hs-type">readData</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568037"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568037"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-706"></span><span id="readData"><span class="annot"><span class="annottext">readData :: forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="Data.Functor.Classes.html#readData"><span class="hs-identifier hs-var hs-var">readData</span></a></span></span><span> </span><span id="local-6989586621679568036"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568036"><span class="hs-identifier hs-var">reader</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec a
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#parens"><span class="hs-identifier hs-var">parens</span></a></span><span> </span><span class="annot"><span class="annottext">(ReadPrec a -&gt; ReadPrec a) -&gt; ReadPrec a -&gt; ReadPrec a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadPrec a -&gt; ReadPrec a
forall a. Int -&gt; ReadPrec a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#prec"><span class="hs-identifier hs-var">prec</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">10</span></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568036"><span class="hs-identifier hs-var">reader</span></a></span><span>
</span><span id="line-707"></span><span>
</span><span id="line-708"></span><span class="hs-comment">-- | @'readsUnaryWith' rp n c n'@ matches the name of a unary data constructor</span><span>
</span><span id="line-709"></span><span class="hs-comment">-- and then parses its argument using @rp@.</span><span>
</span><span id="line-710"></span><span class="hs-comment">--</span><span>
</span><span id="line-711"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-712"></span><span id="local-6989586621679568868"><span id="local-6989586621679568869"><span class="annot"><a href="Data.Functor.Classes.html#readsUnaryWith"><span class="hs-identifier hs-type">readsUnaryWith</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568869"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679568869"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679568868"><span class="hs-identifier hs-type">t</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568868"><span class="hs-identifier hs-type">t</span></a></span></span></span><span>
</span><span id="line-713"></span><span id="readsUnaryWith"><span class="annot"><span class="annottext">readsUnaryWith :: forall a t.
(Int -&gt; ReadS a) -&gt; String -&gt; (a -&gt; t) -&gt; String -&gt; ReadS t
</span><a href="Data.Functor.Classes.html#readsUnaryWith"><span class="hs-identifier hs-var hs-var">readsUnaryWith</span></a></span></span><span> </span><span id="local-6989586621679568031"><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679568031"><span class="hs-identifier hs-var">rp</span></a></span></span><span> </span><span id="local-6989586621679568030"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568030"><span class="hs-identifier hs-var">name</span></a></span></span><span> </span><span id="local-6989586621679568029"><span class="annot"><span class="annottext">a -&gt; t
</span><a href="#local-6989586621679568029"><span class="hs-identifier hs-var">cons</span></a></span></span><span> </span><span id="local-6989586621679568028"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568028"><span class="hs-identifier hs-var">kw</span></a></span></span><span> </span><span id="local-6989586621679568027"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568027"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-714"></span><span>    </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; t
</span><a href="#local-6989586621679568029"><span class="hs-identifier hs-var">cons</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568026"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568025"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568028"><span class="hs-identifier hs-var">kw</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568030"><span class="hs-identifier hs-var">name</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679568026"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568026"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679568025"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568025"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679568031"><span class="hs-identifier hs-var">rp</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">11</span></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568027"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-715"></span><span>
</span><span id="line-716"></span><span class="hs-comment">-- | @'readUnaryWith' rp n c'@ matches the name of a unary data constructor</span><span>
</span><span id="line-717"></span><span class="hs-comment">-- and then parses its argument using @rp@.</span><span>
</span><span id="line-718"></span><span class="hs-comment">--</span><span>
</span><span id="line-719"></span><span class="hs-comment">-- @since 4.10.0.0</span><span>
</span><span id="line-720"></span><span id="local-6989586621679569024"><span id="local-6989586621679569025"><span class="annot"><a href="Data.Functor.Classes.html#readUnaryWith"><span class="hs-identifier hs-type">readUnaryWith</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569025"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679569025"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569024"><span class="hs-identifier hs-type">t</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679569024"><span class="hs-identifier hs-type">t</span></a></span></span></span><span>
</span><span id="line-721"></span><span id="readUnaryWith"><span class="annot"><span class="annottext">readUnaryWith :: forall a t. ReadPrec a -&gt; String -&gt; (a -&gt; t) -&gt; ReadPrec t
</span><a href="Data.Functor.Classes.html#readUnaryWith"><span class="hs-identifier hs-var hs-var">readUnaryWith</span></a></span></span><span> </span><span id="local-6989586621679568021"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568021"><span class="hs-identifier hs-var">rp</span></a></span></span><span> </span><span id="local-6989586621679568020"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568020"><span class="hs-identifier hs-var">name</span></a></span></span><span> </span><span id="local-6989586621679568019"><span class="annot"><span class="annottext">a -&gt; t
</span><a href="#local-6989586621679568019"><span class="hs-identifier hs-var">cons</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-722"></span><span>    </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var">expectP</span></a></span><span> </span><span class="annot"><span class="annottext">(Lexeme -&gt; ReadPrec ()) -&gt; Lexeme -&gt; ReadPrec ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; Lexeme
</span><a href="Text.Read.Lex.html#Ident"><span class="hs-identifier hs-var">Ident</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568020"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-723"></span><span>    </span><span id="local-6989586621679568018"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568018"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec a
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#step"><span class="hs-identifier hs-var">step</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568021"><span class="hs-identifier hs-var">rp</span></a></span><span>
</span><span id="line-724"></span><span>    </span><span class="annot"><span class="annottext">t -&gt; ReadPrec t
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(t -&gt; ReadPrec t) -&gt; t -&gt; ReadPrec t
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; t
</span><a href="#local-6989586621679568019"><span class="hs-identifier hs-var">cons</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568018"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-725"></span><span>
</span><span id="line-726"></span><span class="hs-comment">-- | @'readsBinaryWith' rp1 rp2 n c n'@ matches the name of a binary</span><span>
</span><span id="line-727"></span><span class="hs-comment">-- data constructor and then parses its arguments using @rp1@ and @rp2@</span><span>
</span><span id="line-728"></span><span class="hs-comment">-- respectively.</span><span>
</span><span id="line-729"></span><span class="hs-comment">--</span><span>
</span><span id="line-730"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-731"></span><span id="local-6989586621679568855"><span id="local-6989586621679568856"><span id="local-6989586621679568857"><span class="annot"><a href="Data.Functor.Classes.html#readsBinaryWith"><span class="hs-identifier hs-type">readsBinaryWith</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568857"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568856"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-732"></span><span>    </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679568857"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679568856"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679568855"><span class="hs-identifier hs-type">t</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568855"><span class="hs-identifier hs-type">t</span></a></span></span></span></span><span>
</span><span id="line-733"></span><span id="readsBinaryWith"><span class="annot"><span class="annottext">readsBinaryWith :: forall a b t.
(Int -&gt; ReadS a)
-&gt; (Int -&gt; ReadS b) -&gt; String -&gt; (a -&gt; b -&gt; t) -&gt; String -&gt; ReadS t
</span><a href="Data.Functor.Classes.html#readsBinaryWith"><span class="hs-identifier hs-var hs-var">readsBinaryWith</span></a></span></span><span> </span><span id="local-6989586621679568015"><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679568015"><span class="hs-identifier hs-var">rp1</span></a></span></span><span> </span><span id="local-6989586621679568014"><span class="annot"><span class="annottext">Int -&gt; ReadS b
</span><a href="#local-6989586621679568014"><span class="hs-identifier hs-var">rp2</span></a></span></span><span> </span><span id="local-6989586621679568013"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568013"><span class="hs-identifier hs-var">name</span></a></span></span><span> </span><span id="local-6989586621679568012"><span class="annot"><span class="annottext">a -&gt; b -&gt; t
</span><a href="#local-6989586621679568012"><span class="hs-identifier hs-var">cons</span></a></span></span><span> </span><span id="local-6989586621679568011"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568011"><span class="hs-identifier hs-var">kw</span></a></span></span><span> </span><span id="local-6989586621679568010"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568010"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-734"></span><span>    </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; b -&gt; t
</span><a href="#local-6989586621679568012"><span class="hs-identifier hs-var">cons</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568009"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568008"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568007"><span class="hs-identifier hs-var">u</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568011"><span class="hs-identifier hs-var">kw</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568013"><span class="hs-identifier hs-var">name</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679568009"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679568009"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679568006"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568006"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679568015"><span class="hs-identifier hs-var">rp1</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">11</span></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568010"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679568008"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679568008"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679568007"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568007"><span class="hs-identifier hs-var">u</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS b
</span><a href="#local-6989586621679568014"><span class="hs-identifier hs-var">rp2</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">11</span></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679568006"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-735"></span><span>
</span><span id="line-736"></span><span class="hs-comment">-- | @'readBinaryWith' rp1 rp2 n c'@ matches the name of a binary</span><span>
</span><span id="line-737"></span><span class="hs-comment">-- data constructor and then parses its arguments using @rp1@ and @rp2@</span><span>
</span><span id="line-738"></span><span class="hs-comment">-- respectively.</span><span>
</span><span id="line-739"></span><span class="hs-comment">--</span><span>
</span><span id="line-740"></span><span class="hs-comment">-- @since 4.10.0.0</span><span>
</span><span id="line-741"></span><span id="local-6989586621679568849"><span id="local-6989586621679568850"><span id="local-6989586621679568851"><span class="annot"><a href="Data.Functor.Classes.html#readBinaryWith"><span class="hs-identifier hs-type">readBinaryWith</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568851"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568850"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-742"></span><span>    </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679568851"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679568850"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679568849"><span class="hs-identifier hs-type">t</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568849"><span class="hs-identifier hs-type">t</span></a></span></span></span></span><span>
</span><span id="line-743"></span><span id="readBinaryWith"><span class="annot"><span class="annottext">readBinaryWith :: forall a b t.
ReadPrec a -&gt; ReadPrec b -&gt; String -&gt; (a -&gt; b -&gt; t) -&gt; ReadPrec t
</span><a href="Data.Functor.Classes.html#readBinaryWith"><span class="hs-identifier hs-var hs-var">readBinaryWith</span></a></span></span><span> </span><span id="local-6989586621679568001"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568001"><span class="hs-identifier hs-var">rp1</span></a></span></span><span> </span><span id="local-6989586621679568000"><span class="annot"><span class="annottext">ReadPrec b
</span><a href="#local-6989586621679568000"><span class="hs-identifier hs-var">rp2</span></a></span></span><span> </span><span id="local-6989586621679567999"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567999"><span class="hs-identifier hs-var">name</span></a></span></span><span> </span><span id="local-6989586621679567998"><span class="annot"><span class="annottext">a -&gt; b -&gt; t
</span><a href="#local-6989586621679567998"><span class="hs-identifier hs-var">cons</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-744"></span><span>    </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var">expectP</span></a></span><span> </span><span class="annot"><span class="annottext">(Lexeme -&gt; ReadPrec ()) -&gt; Lexeme -&gt; ReadPrec ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; Lexeme
</span><a href="Text.Read.Lex.html#Ident"><span class="hs-identifier hs-var">Ident</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567999"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-745"></span><span>    </span><span id="local-6989586621679567997"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679567997"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec a
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#step"><span class="hs-identifier hs-var">step</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679568001"><span class="hs-identifier hs-var">rp1</span></a></span><span>
</span><span id="line-746"></span><span>    </span><span id="local-6989586621679567996"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679567996"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec b -&gt; ReadPrec b
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#step"><span class="hs-identifier hs-var">step</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec b
</span><a href="#local-6989586621679568000"><span class="hs-identifier hs-var">rp2</span></a></span><span>
</span><span id="line-747"></span><span>    </span><span class="annot"><span class="annottext">t -&gt; ReadPrec t
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(t -&gt; ReadPrec t) -&gt; t -&gt; ReadPrec t
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; t
</span><a href="#local-6989586621679567998"><span class="hs-identifier hs-var">cons</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679567997"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679567996"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-748"></span><span>
</span><span id="line-749"></span><span class="hs-comment">-- | @'showsUnaryWith' sp n d x@ produces the string representation of a</span><span>
</span><span id="line-750"></span><span class="hs-comment">-- unary data constructor with name @n@ and argument @x@, in precedence</span><span>
</span><span id="line-751"></span><span class="hs-comment">-- context @d@.</span><span>
</span><span id="line-752"></span><span class="hs-comment">--</span><span>
</span><span id="line-753"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-754"></span><span id="local-6989586621679569020"><span class="annot"><a href="Data.Functor.Classes.html#showsUnaryWith"><span class="hs-identifier hs-type">showsUnaryWith</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569020"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679569020"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span></span><span>
</span><span id="line-755"></span><span id="showsUnaryWith"><span class="annot"><span class="annottext">showsUnaryWith :: forall a. (Int -&gt; a -&gt; ShowS) -&gt; String -&gt; Int -&gt; a -&gt; ShowS
</span><a href="Data.Functor.Classes.html#showsUnaryWith"><span class="hs-identifier hs-var hs-var">showsUnaryWith</span></a></span></span><span> </span><span id="local-6989586621679567993"><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679567993"><span class="hs-identifier hs-var">sp</span></a></span></span><span> </span><span id="local-6989586621679567992"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567992"><span class="hs-identifier hs-var">name</span></a></span></span><span> </span><span id="local-6989586621679567991"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679567991"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span id="local-6989586621679567990"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679567990"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; ShowS -&gt; ShowS
</span><a href="GHC.Show.html#showParen"><span class="hs-identifier hs-var">showParen</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679567991"><span class="hs-identifier hs-var">d</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E"><span class="hs-operator hs-var">&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">10</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(ShowS -&gt; ShowS) -&gt; ShowS -&gt; ShowS
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-756"></span><span>    </span><span class="annot"><span class="annottext">String -&gt; ShowS
</span><a href="GHC.Show.html#showString"><span class="hs-identifier hs-var">showString</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567992"><span class="hs-identifier hs-var">name</span></a></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; ShowS -&gt; ShowS
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; ShowS
</span><a href="GHC.Show.html#showChar"><span class="hs-identifier hs-var">showChar</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">' '</span></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; ShowS -&gt; ShowS
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679567993"><span class="hs-identifier hs-var">sp</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">11</span></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679567990"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-757"></span><span>
</span><span id="line-758"></span><span class="hs-comment">-- | @'showsBinaryWith' sp1 sp2 n d x y@ produces the string</span><span>
</span><span id="line-759"></span><span class="hs-comment">-- representation of a binary data constructor with name @n@ and arguments</span><span>
</span><span id="line-760"></span><span class="hs-comment">-- @x@ and @y@, in precedence context @d@.</span><span>
</span><span id="line-761"></span><span class="hs-comment">--</span><span>
</span><span id="line-762"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-763"></span><span id="local-6989586621679568843"><span id="local-6989586621679568844"><span class="annot"><a href="Data.Functor.Classes.html#showsBinaryWith"><span class="hs-identifier hs-type">showsBinaryWith</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679568844"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679568843"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-764"></span><span>    </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679568844"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679568843"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span></span></span><span>
</span><span id="line-765"></span><span id="showsBinaryWith"><span class="annot"><span class="annottext">showsBinaryWith :: forall a b.
(Int -&gt; a -&gt; ShowS)
-&gt; (Int -&gt; b -&gt; ShowS) -&gt; String -&gt; Int -&gt; a -&gt; b -&gt; ShowS
</span><a href="Data.Functor.Classes.html#showsBinaryWith"><span class="hs-identifier hs-var hs-var">showsBinaryWith</span></a></span></span><span> </span><span id="local-6989586621679567987"><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679567987"><span class="hs-identifier hs-var">sp1</span></a></span></span><span> </span><span id="local-6989586621679567986"><span class="annot"><span class="annottext">Int -&gt; b -&gt; ShowS
</span><a href="#local-6989586621679567986"><span class="hs-identifier hs-var">sp2</span></a></span></span><span> </span><span id="local-6989586621679567985"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567985"><span class="hs-identifier hs-var">name</span></a></span></span><span> </span><span id="local-6989586621679567984"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679567984"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span id="local-6989586621679567983"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679567983"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679567982"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679567982"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; ShowS -&gt; ShowS
</span><a href="GHC.Show.html#showParen"><span class="hs-identifier hs-var">showParen</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679567984"><span class="hs-identifier hs-var">d</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E"><span class="hs-operator hs-var">&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">10</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(ShowS -&gt; ShowS) -&gt; ShowS -&gt; ShowS
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-766"></span><span>    </span><span class="annot"><span class="annottext">String -&gt; ShowS
</span><a href="GHC.Show.html#showString"><span class="hs-identifier hs-var">showString</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567985"><span class="hs-identifier hs-var">name</span></a></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; ShowS -&gt; ShowS
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; ShowS
</span><a href="GHC.Show.html#showChar"><span class="hs-identifier hs-var">showChar</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">' '</span></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; ShowS -&gt; ShowS
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679567987"><span class="hs-identifier hs-var">sp1</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">11</span></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679567983"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; ShowS -&gt; ShowS
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; ShowS
</span><a href="GHC.Show.html#showChar"><span class="hs-identifier hs-var">showChar</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">' '</span></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; ShowS -&gt; ShowS
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; b -&gt; ShowS
</span><a href="#local-6989586621679567986"><span class="hs-identifier hs-var">sp2</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">11</span></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679567982"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-767"></span><span>
</span><span id="line-768"></span><span class="hs-comment">-- Obsolete building blocks</span><span>
</span><span id="line-769"></span><span>
</span><span id="line-770"></span><span class="hs-comment">-- | @'readsUnary' n c n'@ matches the name of a unary data constructor</span><span>
</span><span id="line-771"></span><span class="hs-comment">-- and then parses its argument using 'readsPrec'.</span><span>
</span><span id="line-772"></span><span class="hs-comment">--</span><span>
</span><span id="line-773"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-774"></span><span class="hs-pragma">{-# DEPRECATED</span><span> </span><span class="hs-pragma">readsUnary</span><span> </span><span class="hs-pragma">&quot;Use 'readsUnaryWith' to define 'liftReadsPrec'&quot;</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-775"></span><span id="local-6989586621679568839"><span id="local-6989586621679568840"><span class="annot"><a href="Data.Functor.Classes.html#readsUnary"><span class="hs-identifier hs-type">readsUnary</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568840"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679568840"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679568839"><span class="hs-identifier hs-type">t</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568839"><span class="hs-identifier hs-type">t</span></a></span></span></span><span>
</span><span id="line-776"></span><span id="readsUnary"><span class="annot"><span class="annottext">readsUnary :: forall a t. Read a =&gt; String -&gt; (a -&gt; t) -&gt; String -&gt; ReadS t
</span><a href="Data.Functor.Classes.html#readsUnary"><span class="hs-identifier hs-var hs-var">readsUnary</span></a></span></span><span> </span><span id="local-6989586621679567977"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567977"><span class="hs-identifier hs-var">name</span></a></span></span><span> </span><span id="local-6989586621679567976"><span class="annot"><span class="annottext">a -&gt; t
</span><a href="#local-6989586621679567976"><span class="hs-identifier hs-var">cons</span></a></span></span><span> </span><span id="local-6989586621679567975"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567975"><span class="hs-identifier hs-var">kw</span></a></span></span><span> </span><span id="local-6989586621679567974"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567974"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-777"></span><span>    </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; t
</span><a href="#local-6989586621679567976"><span class="hs-identifier hs-var">cons</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679567973"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567972"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567975"><span class="hs-identifier hs-var">kw</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567977"><span class="hs-identifier hs-var">name</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679567973"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679567973"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679567972"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567972"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS a
forall a. Read a =&gt; Int -&gt; ReadS a
</span><a href="GHC.Read.html#readsPrec"><span class="hs-identifier hs-var">readsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">11</span></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567974"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-778"></span><span>
</span><span id="line-779"></span><span class="hs-comment">-- | @'readsUnary1' n c n'@ matches the name of a unary data constructor</span><span>
</span><span id="line-780"></span><span class="hs-comment">-- and then parses its argument using 'readsPrec1'.</span><span>
</span><span id="line-781"></span><span class="hs-comment">--</span><span>
</span><span id="line-782"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-783"></span><span class="hs-pragma">{-# DEPRECATED</span><span> </span><span class="hs-pragma">readsUnary1</span><span> </span><span class="hs-pragma">&quot;Use 'readsUnaryWith' to define 'liftReadsPrec'&quot;</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-784"></span><span id="local-6989586621679568834"><span id="local-6989586621679568835"><span id="local-6989586621679568836"><span class="annot"><a href="Data.Functor.Classes.html#readsUnary1"><span class="hs-identifier hs-type">readsUnary1</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Classes.html#Read1"><span class="hs-identifier hs-type">Read1</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568836"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568835"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679568836"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568835"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679568834"><span class="hs-identifier hs-type">t</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568834"><span class="hs-identifier hs-type">t</span></a></span></span></span></span><span>
</span><span id="line-785"></span><span id="readsUnary1"><span class="annot"><span class="annottext">readsUnary1 :: forall (f :: * -&gt; *) a t.
(Read1 f, Read a) =&gt;
String -&gt; (f a -&gt; t) -&gt; String -&gt; ReadS t
</span><a href="Data.Functor.Classes.html#readsUnary1"><span class="hs-identifier hs-var hs-var">readsUnary1</span></a></span></span><span> </span><span id="local-6989586621679567965"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567965"><span class="hs-identifier hs-var">name</span></a></span></span><span> </span><span id="local-6989586621679567964"><span class="annot"><span class="annottext">f a -&gt; t
</span><a href="#local-6989586621679567964"><span class="hs-identifier hs-var">cons</span></a></span></span><span> </span><span id="local-6989586621679567963"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567963"><span class="hs-identifier hs-var">kw</span></a></span></span><span> </span><span id="local-6989586621679567962"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567962"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-786"></span><span>    </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><span class="annottext">f a -&gt; t
</span><a href="#local-6989586621679567964"><span class="hs-identifier hs-var">cons</span></a></span><span> </span><span class="annot"><span class="annottext">f a
</span><a href="#local-6989586621679567961"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567960"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567963"><span class="hs-identifier hs-var">kw</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567965"><span class="hs-identifier hs-var">name</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679567961"><span class="annot"><span class="annottext">f a
</span><a href="#local-6989586621679567961"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679567960"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567960"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS (f a)
forall (f :: * -&gt; *) a. (Read1 f, Read a) =&gt; Int -&gt; ReadS (f a)
</span><a href="Data.Functor.Classes.html#readsPrec1"><span class="hs-identifier hs-var">readsPrec1</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">11</span></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567962"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-787"></span><span>
</span><span id="line-788"></span><span class="hs-comment">-- | @'readsBinary1' n c n'@ matches the name of a binary data constructor</span><span>
</span><span id="line-789"></span><span class="hs-comment">-- and then parses its arguments using 'readsPrec1'.</span><span>
</span><span id="line-790"></span><span class="hs-comment">--</span><span>
</span><span id="line-791"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-792"></span><span class="hs-pragma">{-# DEPRECATED</span><span> </span><span class="hs-pragma">readsBinary1</span><span>
</span><span id="line-793"></span><span>      </span><span class="hs-pragma">&quot;Use 'readsBinaryWith' to define 'liftReadsPrec'&quot;</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-794"></span><span id="local-6989586621679568827"><span id="local-6989586621679568828"><span id="local-6989586621679568829"><span id="local-6989586621679568830"><span class="annot"><a href="Data.Functor.Classes.html#readsBinary1"><span class="hs-identifier hs-type">readsBinary1</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Classes.html#Read1"><span class="hs-identifier hs-type">Read1</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568830"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Read1"><span class="hs-identifier hs-type">Read1</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568829"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568828"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span>
</span><span id="line-795"></span><span>    </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679568830"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568828"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679568829"><span class="hs-identifier hs-type">g</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568828"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679568827"><span class="hs-identifier hs-type">t</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568827"><span class="hs-identifier hs-type">t</span></a></span></span></span></span></span><span>
</span><span id="line-796"></span><span id="readsBinary1"><span class="annot"><span class="annottext">readsBinary1 :: forall (f :: * -&gt; *) (g :: * -&gt; *) a t.
(Read1 f, Read1 g, Read a) =&gt;
String -&gt; (f a -&gt; g a -&gt; t) -&gt; String -&gt; ReadS t
</span><a href="Data.Functor.Classes.html#readsBinary1"><span class="hs-identifier hs-var hs-var">readsBinary1</span></a></span></span><span> </span><span id="local-6989586621679567950"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567950"><span class="hs-identifier hs-var">name</span></a></span></span><span> </span><span id="local-6989586621679567949"><span class="annot"><span class="annottext">f a -&gt; g a -&gt; t
</span><a href="#local-6989586621679567949"><span class="hs-identifier hs-var">cons</span></a></span></span><span> </span><span id="local-6989586621679567948"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567948"><span class="hs-identifier hs-var">kw</span></a></span></span><span> </span><span id="local-6989586621679567947"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567947"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-797"></span><span>    </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><span class="annottext">f a -&gt; g a -&gt; t
</span><a href="#local-6989586621679567949"><span class="hs-identifier hs-var">cons</span></a></span><span> </span><span class="annot"><span class="annottext">f a
</span><a href="#local-6989586621679567946"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">g a
</span><a href="#local-6989586621679567945"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567944"><span class="hs-identifier hs-var">u</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567948"><span class="hs-identifier hs-var">kw</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567950"><span class="hs-identifier hs-var">name</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-798"></span><span>        </span><span class="hs-special">(</span><span id="local-6989586621679567946"><span class="annot"><span class="annottext">f a
</span><a href="#local-6989586621679567946"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679567943"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567943"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS (f a)
forall (f :: * -&gt; *) a. (Read1 f, Read a) =&gt; Int -&gt; ReadS (f a)
</span><a href="Data.Functor.Classes.html#readsPrec1"><span class="hs-identifier hs-var">readsPrec1</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">11</span></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567947"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679567945"><span class="annot"><span class="annottext">g a
</span><a href="#local-6989586621679567945"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679567944"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567944"><span class="hs-identifier hs-var">u</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS (g a)
forall (f :: * -&gt; *) a. (Read1 f, Read a) =&gt; Int -&gt; ReadS (f a)
</span><a href="Data.Functor.Classes.html#readsPrec1"><span class="hs-identifier hs-var">readsPrec1</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">11</span></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567943"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-799"></span><span>
</span><span id="line-800"></span><span class="hs-comment">-- | @'showsUnary' n d x@ produces the string representation of a unary data</span><span>
</span><span id="line-801"></span><span class="hs-comment">-- constructor with name @n@ and argument @x@, in precedence context @d@.</span><span>
</span><span id="line-802"></span><span class="hs-comment">--</span><span>
</span><span id="line-803"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-804"></span><span class="hs-pragma">{-# DEPRECATED</span><span> </span><span class="hs-pragma">showsUnary</span><span> </span><span class="hs-pragma">&quot;Use 'showsUnaryWith' to define 'liftShowsPrec'&quot;</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-805"></span><span id="local-6989586621679568822"><span class="annot"><a href="Data.Functor.Classes.html#showsUnary"><span class="hs-identifier hs-type">showsUnary</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Show.html#Show"><span class="hs-identifier hs-type">Show</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568822"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679568822"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span></span><span>
</span><span id="line-806"></span><span id="showsUnary"><span class="annot"><span class="annottext">showsUnary :: forall a. Show a =&gt; String -&gt; Int -&gt; a -&gt; ShowS
</span><a href="Data.Functor.Classes.html#showsUnary"><span class="hs-identifier hs-var hs-var">showsUnary</span></a></span></span><span> </span><span id="local-6989586621679567938"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567938"><span class="hs-identifier hs-var">name</span></a></span></span><span> </span><span id="local-6989586621679567937"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679567937"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span id="local-6989586621679567936"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679567936"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; ShowS -&gt; ShowS
</span><a href="GHC.Show.html#showParen"><span class="hs-identifier hs-var">showParen</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679567937"><span class="hs-identifier hs-var">d</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E"><span class="hs-operator hs-var">&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">10</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(ShowS -&gt; ShowS) -&gt; ShowS -&gt; ShowS
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-807"></span><span>    </span><span class="annot"><span class="annottext">String -&gt; ShowS
</span><a href="GHC.Show.html#showString"><span class="hs-identifier hs-var">showString</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567938"><span class="hs-identifier hs-var">name</span></a></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; ShowS -&gt; ShowS
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; ShowS
</span><a href="GHC.Show.html#showChar"><span class="hs-identifier hs-var">showChar</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">' '</span></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; ShowS -&gt; ShowS
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
forall a. Show a =&gt; Int -&gt; a -&gt; ShowS
</span><a href="GHC.Show.html#showsPrec"><span class="hs-identifier hs-var">showsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">11</span></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679567936"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-808"></span><span>
</span><span id="line-809"></span><span class="hs-comment">-- | @'showsUnary1' n d x@ produces the string representation of a unary data</span><span>
</span><span id="line-810"></span><span class="hs-comment">-- constructor with name @n@ and argument @x@, in precedence context @d@.</span><span>
</span><span id="line-811"></span><span class="hs-comment">--</span><span>
</span><span id="line-812"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-813"></span><span class="hs-pragma">{-# DEPRECATED</span><span> </span><span class="hs-pragma">showsUnary1</span><span> </span><span class="hs-pragma">&quot;Use 'showsUnaryWith' to define 'liftShowsPrec'&quot;</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-814"></span><span id="local-6989586621679568819"><span id="local-6989586621679568820"><span class="annot"><a href="Data.Functor.Classes.html#showsUnary1"><span class="hs-identifier hs-type">showsUnary1</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Classes.html#Show1"><span class="hs-identifier hs-type">Show1</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568820"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Show.html#Show"><span class="hs-identifier hs-type">Show</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568819"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679568820"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568819"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span></span></span><span>
</span><span id="line-815"></span><span id="showsUnary1"><span class="annot"><span class="annottext">showsUnary1 :: forall (f :: * -&gt; *) a.
(Show1 f, Show a) =&gt;
String -&gt; Int -&gt; f a -&gt; ShowS
</span><a href="Data.Functor.Classes.html#showsUnary1"><span class="hs-identifier hs-var hs-var">showsUnary1</span></a></span></span><span> </span><span id="local-6989586621679567929"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567929"><span class="hs-identifier hs-var">name</span></a></span></span><span> </span><span id="local-6989586621679567928"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679567928"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span id="local-6989586621679567927"><span class="annot"><span class="annottext">f a
</span><a href="#local-6989586621679567927"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; ShowS -&gt; ShowS
</span><a href="GHC.Show.html#showParen"><span class="hs-identifier hs-var">showParen</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679567928"><span class="hs-identifier hs-var">d</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E"><span class="hs-operator hs-var">&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">10</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(ShowS -&gt; ShowS) -&gt; ShowS -&gt; ShowS
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-816"></span><span>    </span><span class="annot"><span class="annottext">String -&gt; ShowS
</span><a href="GHC.Show.html#showString"><span class="hs-identifier hs-var">showString</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567929"><span class="hs-identifier hs-var">name</span></a></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; ShowS -&gt; ShowS
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; ShowS
</span><a href="GHC.Show.html#showChar"><span class="hs-identifier hs-var">showChar</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">' '</span></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; ShowS -&gt; ShowS
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; f a -&gt; ShowS
forall (f :: * -&gt; *) a. (Show1 f, Show a) =&gt; Int -&gt; f a -&gt; ShowS
</span><a href="Data.Functor.Classes.html#showsPrec1"><span class="hs-identifier hs-var">showsPrec1</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">11</span></span><span> </span><span class="annot"><span class="annottext">f a
</span><a href="#local-6989586621679567927"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-817"></span><span>
</span><span id="line-818"></span><span class="hs-comment">-- | @'showsBinary1' n d x y@ produces the string representation of a binary</span><span>
</span><span id="line-819"></span><span class="hs-comment">-- data constructor with name @n@ and arguments @x@ and @y@, in precedence</span><span>
</span><span id="line-820"></span><span class="hs-comment">-- context @d@.</span><span>
</span><span id="line-821"></span><span class="hs-comment">--</span><span>
</span><span id="line-822"></span><span class="hs-comment">-- @since 4.9.0.0</span><span>
</span><span id="line-823"></span><span class="hs-pragma">{-# DEPRECATED</span><span> </span><span class="hs-pragma">showsBinary1</span><span>
</span><span id="line-824"></span><span>      </span><span class="hs-pragma">&quot;Use 'showsBinaryWith' to define 'liftShowsPrec'&quot;</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-825"></span><span id="local-6989586621679568814"><span id="local-6989586621679568815"><span id="local-6989586621679568816"><span class="annot"><a href="Data.Functor.Classes.html#showsBinary1"><span class="hs-identifier hs-type">showsBinary1</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Classes.html#Show1"><span class="hs-identifier hs-type">Show1</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568816"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Functor.Classes.html#Show1"><span class="hs-identifier hs-type">Show1</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568815"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Show.html#Show"><span class="hs-identifier hs-type">Show</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568814"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span>
</span><span id="line-826"></span><span>    </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679568816"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568814"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679568815"><span class="hs-identifier hs-type">g</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679568814"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Show.html#ShowS"><span class="hs-identifier hs-type">ShowS</span></a></span></span></span></span><span>
</span><span id="line-827"></span><span id="showsBinary1"><span class="annot"><span class="annottext">showsBinary1 :: forall (f :: * -&gt; *) (g :: * -&gt; *) a.
(Show1 f, Show1 g, Show a) =&gt;
String -&gt; Int -&gt; f a -&gt; g a -&gt; ShowS
</span><a href="Data.Functor.Classes.html#showsBinary1"><span class="hs-identifier hs-var hs-var">showsBinary1</span></a></span></span><span> </span><span id="local-6989586621679567917"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567917"><span class="hs-identifier hs-var">name</span></a></span></span><span> </span><span id="local-6989586621679567916"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679567916"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span id="local-6989586621679567915"><span class="annot"><span class="annottext">f a
</span><a href="#local-6989586621679567915"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679567914"><span class="annot"><span class="annottext">g a
</span><a href="#local-6989586621679567914"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; ShowS -&gt; ShowS
</span><a href="GHC.Show.html#showParen"><span class="hs-identifier hs-var">showParen</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679567916"><span class="hs-identifier hs-var">d</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E"><span class="hs-operator hs-var">&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">10</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(ShowS -&gt; ShowS) -&gt; ShowS -&gt; ShowS
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-828"></span><span>    </span><span class="annot"><span class="annottext">String -&gt; ShowS
</span><a href="GHC.Show.html#showString"><span class="hs-identifier hs-var">showString</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679567917"><span class="hs-identifier hs-var">name</span></a></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; ShowS -&gt; ShowS
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; ShowS
</span><a href="GHC.Show.html#showChar"><span class="hs-identifier hs-var">showChar</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">' '</span></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; ShowS -&gt; ShowS
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; f a -&gt; ShowS
forall (f :: * -&gt; *) a. (Show1 f, Show a) =&gt; Int -&gt; f a -&gt; ShowS
</span><a href="Data.Functor.Classes.html#showsPrec1"><span class="hs-identifier hs-var">showsPrec1</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">11</span></span><span> </span><span class="annot"><span class="annottext">f a
</span><a href="#local-6989586621679567915"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; ShowS -&gt; ShowS
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span>
</span><span id="line-829"></span><span>        </span><span class="annot"><span class="annottext">Char -&gt; ShowS
</span><a href="GHC.Show.html#showChar"><span class="hs-identifier hs-var">showChar</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">' '</span></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; ShowS -&gt; ShowS
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; g a -&gt; ShowS
forall (f :: * -&gt; *) a. (Show1 f, Show a) =&gt; Int -&gt; f a -&gt; ShowS
</span><a href="Data.Functor.Classes.html#showsPrec1"><span class="hs-identifier hs-var">showsPrec1</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">11</span></span><span> </span><span class="annot"><span class="annottext">g a
</span><a href="#local-6989586621679567914"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-830"></span><span>
</span><span id="line-831"></span><span class="hs-comment">{- $example
These functions can be used to assemble 'Read' and 'Show' instances for
new algebraic types.  For example, given the definition

&gt; data T f a = Zero a | One (f a) | Two a (f a)

a standard 'Read1' instance may be defined as

&gt; instance (Read1 f) =&gt; Read1 (T f) where
&gt;     liftReadPrec rp rl = readData $
&gt;         readUnaryWith rp &quot;Zero&quot; Zero &lt;|&gt;
&gt;         readUnaryWith (liftReadPrec rp rl) &quot;One&quot; One &lt;|&gt;
&gt;         readBinaryWith rp (liftReadPrec rp rl) &quot;Two&quot; Two
&gt;     liftReadListPrec = liftReadListPrecDefault

and the corresponding 'Show1' instance as

&gt; instance (Show1 f) =&gt; Show1 (T f) where
&gt;     liftShowsPrec sp _ d (Zero x) =
&gt;         showsUnaryWith sp &quot;Zero&quot; d x
&gt;     liftShowsPrec sp sl d (One x) =
&gt;         showsUnaryWith (liftShowsPrec sp sl) &quot;One&quot; d x
&gt;     liftShowsPrec sp sl d (Two x y) =
&gt;         showsBinaryWith sp (liftShowsPrec sp sl) &quot;Two&quot; d x y

-}</span><span>
</span><span id="line-857"></span></pre></body></html>